module objects' type as PyModule

compiler/ast/asdl_rs.py

@@ -474,7 +474,7 @@ class ExtendModuleVisitor(EmitVisitor):
     def visitModule(self, mod):
         depth = 0
         self.emit(
-            "pub fn extend_module_nodes(vm: &VirtualMachine, module: &PyObject) {",
+            "pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {",
             depth,
         )
         self.emit("extend_module!(vm, module, {", depth + 1)

derive-impl/src/pymodule.rs

@@ -114,7 +114,7 @@ pub fn impl_pymodule(attr: AttributeArgs, module_item: Item) -> Result<TokenStre
         parse_quote! {
             pub(crate) fn extend_module(
                 vm: &::rustpython_vm::VirtualMachine,
-                module: &::rustpython_vm::PyObject,
+                module: &::rustpython_vm::Py<::rustpython_vm::builtins::PyModule>,
             ) {
                 #module_extend_items
             }
@@ -123,7 +123,7 @@ pub fn impl_pymodule(attr: AttributeArgs, module_item: Item) -> Result<TokenStre
             #[allow(dead_code)]
             pub(crate) fn make_module(
                 vm: &::rustpython_vm::VirtualMachine
-            ) -> ::rustpython_vm::PyObjectRef {
+            ) -> ::rustpython_vm::PyRef<::rustpython_vm::builtins::PyModule> {
                 let module = vm.new_module(MODULE_NAME, vm.ctx.new_dict(), DOC);
                 extend_module(vm, &module);
                 module

src/lib.rs

@@ -99,15 +99,12 @@ fn setup_main_module(vm: &VirtualMachine) -> PyResult<Scope> {
     let main_module = vm.new_module("__main__", scope.globals.clone(), None);
     main_module
         .dict()
-        .and_then(|d| {
-            d.set_item("__annotations__", vm.ctx.new_dict().into(), vm)
-                .ok()
-        })
+        .set_item("__annotations__", vm.ctx.new_dict().into(), vm)
         .expect("Failed to initialize __main__.__annotations__");
 
     vm.sys_module
         .get_attr("modules", vm)?
-        .set_item("__main__", main_module, vm)?;
+        .set_item("__main__", main_module.into(), vm)?;
 
     Ok(scope)
 }

stdlib/src/array.rs

@@ -1,8 +1,8 @@
 // spell-checker:ignore typecode tofile tolist fromfile
 
-use rustpython_vm::{PyObjectRef, VirtualMachine};
+use rustpython_vm::{builtins::PyModule, PyRef, VirtualMachine};
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = array::make_module(vm);
 
     let array = module

stdlib/src/pyexpat.rs

@@ -3,12 +3,12 @@
 *
 */
 
-use crate::vm::{extend_module, PyObjectRef, VirtualMachine};
+use crate::vm::{builtins::PyModule, extend_module, PyRef, VirtualMachine};
 
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _pyexpat::make_module(vm);
 
-    extend_module!(vm, module, {
+    extend_module!(vm, &module, {
          "errors" => _errors::make_module(vm),
          "model" => _model::make_module(vm),
     });

stdlib/src/select.rs

@@ -1,9 +1,10 @@
 use crate::vm::{
-    builtins::PyListRef, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::PyListRef, builtins::PyModule, PyObject, PyObjectRef, PyRef, PyResult, TryFromObject,
+    VirtualMachine,
 };
 use std::{io, mem};
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     #[cfg(windows)]
     crate::vm::stdlib::nt::init_winsock();
 

stdlib/src/socket.rs

@@ -1,8 +1,8 @@
-use crate::vm::{PyObjectRef, VirtualMachine};
+use crate::vm::{builtins::PyModule, PyRef, VirtualMachine};
 #[cfg(feature = "ssl")]
 pub(super) use _socket::{sock_select, timeout_error_msg, PySocket, SelectKind};
 
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     #[cfg(windows)]
     crate::vm::stdlib::nt::init_winsock();
     _socket::make_module(vm)

stdlib/src/sqlite.rs

@@ -8,13 +8,13 @@
 // spell-checker:ignore cantlock commithook foreignkey notnull primarykey gettemppath autoindex convpath
 // spell-checker:ignore dbmoved vnode nbytes
 
-use rustpython_vm::{PyObjectRef, VirtualMachine};
+use rustpython_vm::{builtins::PyModule, AsObject, PyRef, VirtualMachine};
 
 // pub(crate) use _sqlite::make_module;
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     // TODO: sqlite version check
     let module = _sqlite::make_module(vm);
-    _sqlite::setup_module(&module, vm);
+    _sqlite::setup_module(module.as_object(), vm);
     module
 }
 

stdlib/src/ssl.rs

@@ -1,6 +1,6 @@
-use crate::vm::{PyObjectRef, VirtualMachine};
+use crate::vm::{builtins::PyModule, PyRef, VirtualMachine};
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     // if openssl is vendored, it doesn't know the locations of system certificates
     #[cfg(feature = "ssl-vendor")]
     if let None | Some("0") = option_env!("OPENSSL_NO_VENDOR") {

stdlib/src/unicodedata.rs

@@ -5,11 +5,11 @@
 // spell-checker:ignore nfkc unistr unidata
 
 use crate::vm::{
-    builtins::PyStr, convert::TryFromBorrowedObject, PyObject, PyObjectRef, PyPayload, PyResult,
-    VirtualMachine,
+    builtins::PyModule, builtins::PyStr, convert::TryFromBorrowedObject, PyObject, PyObjectRef,
+    PyPayload, PyRef, PyResult, VirtualMachine,
 };
 
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = unicodedata::make_module(vm);
 
     let ucd: PyObjectRef = unicodedata::Ucd::new(unic_ucd_age::UNICODE_VERSION)

vm/src/import.rs

@@ -85,6 +85,7 @@ pub fn make_frozen(vm: &VirtualMachine, name: &str) -> PyResult<PyRef<PyCode>> {
 pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
     let frozen = make_frozen(vm, module_name)?;
     let module = import_codeobj(vm, module_name, frozen, false)?;
+    debug_assert!(module.get_attr(identifier!(vm, __name__), vm).is_ok());
     // TODO: give a correct origname here
     module.set_attr("__origname__", vm.ctx.new_str(module_name.to_owned()), vm)?;
     Ok(module)
@@ -99,8 +100,8 @@ pub fn import_builtin(vm: &VirtualMachine, module_name: &str) -> PyResult {
     })?;
     let module = make_module_func(vm);
     let sys_modules = vm.sys_module.get_attr("modules", vm)?;
-    sys_modules.set_item(module_name, module.clone(), vm)?;
-    Ok(module)
+    sys_modules.set_item(module_name, module.as_object().to_owned(), vm)?;
+    Ok(module.into())
 }
 
 #[cfg(feature = "rustpython-compiler")]
@@ -144,12 +145,12 @@ pub fn import_codeobj(
 
     // Store module in cache to prevent infinite loop with mutual importing libs:
     let sys_modules = vm.sys_module.get_attr("modules", vm)?;
-    sys_modules.set_item(module_name, module.clone(), vm)?;
+    sys_modules.set_item(module_name, module.clone().into(), vm)?;
 
     // Execute main code in module:
     let scope = Scope::with_builtins(None, attrs, vm);
     vm.run_code_obj(code_obj, scope)?;
-    Ok(module)
+    Ok(module.into())
 }
 
 fn remove_importlib_frames_inner(

vm/src/macros.rs

@@ -1,10 +1,8 @@
 #[macro_export]
 macro_rules! extend_module {
     ( $vm:expr, $module:expr, { $($name:expr => $value:expr),* $(,)? }) => {{
-        #[allow(unused_variables)]
-        let module: &$crate::PyObject = &$module;
         $(
-            $vm.__module_set_attr(&module, $name, $value).unwrap();
+            $vm.__module_set_attr($module, $name, $value).unwrap();
         )*
     }};
 }
@@ -48,8 +46,9 @@ macro_rules! py_namespace {
     ( $vm:expr, { $($name:expr => $value:expr),* $(,)* }) => {
         {
             let namespace = $crate::builtins::PyNamespace::new_ref(&$vm.ctx);
+            let obj = $crate::object::AsObject::as_object(&namespace);
             $(
-                $vm.__module_set_attr($crate::object::AsObject::as_object(&namespace), $name, $value).unwrap();
+                obj.generic_setattr($vm.ctx.intern_str($name), $crate::function::PySetterValue::Assign($value.into()), $vm).unwrap();
             )*
             namespace
         }

vm/src/stdlib/ast.rs

@@ -6,11 +6,11 @@
 mod gen;
 
 use crate::{
-    builtins::{self, PyStrRef, PyType},
+    builtins::{self, PyModule, PyStrRef, PyType},
     class::{PyClassImpl, StaticType},
     compiler::CompileError,
     convert::ToPyException,
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject,
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     VirtualMachine,
 };
 use num_complex::Complex64;
@@ -331,7 +331,7 @@ pub(crate) use _ast::AstNode;
 // Used by builtins::compile()
 pub const PY_COMPILE_FLAG_AST_ONLY: i32 = 0x0400;
 
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _ast::make_module(vm);
     gen::extend_module_nodes(vm, &module);
     module

vm/src/stdlib/ast/gen.rs

@@ -4535,7 +4535,7 @@ impl Node for ast::TypeIgnore {
     }
 }
 
-pub fn extend_module_nodes(vm: &VirtualMachine, module: &PyObject) {
+pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
     extend_module!(vm, module, {
         "mod" => NodeKindMod::make_class(&vm.ctx),
         "Module" => NodeModule::make_class(&vm.ctx),

vm/src/stdlib/builtins.rs

@@ -1,7 +1,8 @@
 //! Builtin function definitions.
 //!
 //! Implements the list of [builtin Python functions](https://docs.python.org/3/library/builtins.html).
-use crate::{class::PyClassImpl, PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, class::PyClassImpl, Py, VirtualMachine};
+pub use builtins::{ascii, print};
 
 #[pymodule]
 mod builtins {
@@ -933,14 +934,12 @@ mod builtins {
     }
 }
 
-pub use builtins::{ascii, print};
-
-pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
+pub fn init_module(vm: &VirtualMachine, module: &Py<PyModule>) {
     let ctx = &vm.ctx;
 
     crate::protocol::VecBuffer::make_class(&vm.ctx);
 
-    builtins::extend_module(vm, &module);
+    builtins::extend_module(vm, module);
 
     let debug_mode: bool = vm.state.settings.optimize == 0;
     extend_module!(vm, module, {

vm/src/stdlib/errno.rs

@@ -1,13 +1,12 @@
-use crate::PyObjectRef;
-use crate::VirtualMachine;
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 
 #[pymodule]
 mod errno {}
 
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = errno::make_module(vm);
     let errorcode = vm.ctx.new_dict();
-    extend_module!(vm, module, {
+    extend_module!(vm, &module, {
         "errorcode" => errorcode.clone(),
     });
     for (name, code) in ERROR_CODES {

vm/src/stdlib/imp.rs

@@ -1,7 +1,10 @@
 use crate::bytecode::frozen_lib::FrozenModule;
-use crate::{builtins::PyBaseExceptionRef, PyObjectRef, VirtualMachine};
+use crate::{
+    builtins::{PyBaseExceptionRef, PyModule},
+    PyRef, VirtualMachine,
+};
 
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _imp::make_module(vm);
     lock::extend_module(vm, &module);
     module
@@ -120,7 +123,7 @@ mod _imp {
         if let Ok(module) = sys_modules.get_item(&*name, vm) {
             Ok(module)
         } else if let Some(make_module_func) = vm.state.module_inits.get(name.as_str()) {
-            Ok(make_module_func(vm))
+            Ok(make_module_func(vm).into())
         } else {
             Ok(vm.ctx.none())
         }

vm/src/stdlib/io.rs

@@ -11,8 +11,9 @@ cfg_if::cfg_if! {
 
 use crate::{
     builtins::PyBaseExceptionRef,
+    builtins::PyModule,
     convert::{IntoPyException, ToPyException, ToPyObject},
-    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
 };
 pub use _io::io_open as open;
 
@@ -44,7 +45,7 @@ impl IntoPyException for std::io::Error {
     }
 }
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let ctx = &vm.ctx;
 
     let module = _io::make_module(vm);
@@ -55,7 +56,7 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     let unsupported_operation = _io::UNSUPPORTED_OPERATION
         .get_or_init(|| _io::make_unsupportedop(ctx))
         .clone();
-    extend_module!(vm, module, {
+    extend_module!(vm, &module, {
         "UnsupportedOperation" => unsupported_operation,
         "BlockingIOError" => ctx.exceptions.blocking_io_error.to_owned(),
     });

vm/src/stdlib/mod.rs

@@ -48,10 +48,10 @@ mod winapi;
 #[cfg(windows)]
 mod winreg;
 
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 use std::{borrow::Cow, collections::HashMap};
 
-pub type StdlibInitFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine) -> PyObjectRef)>;
+pub type StdlibInitFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine) -> PyRef<PyModule>)>;
 pub type StdlibMap = HashMap<Cow<'static, str>, StdlibInitFunc, ahash::RandomState>;
 
 pub fn get_module_inits() -> StdlibMap {

vm/src/stdlib/nt.rs

@@ -1,8 +1,8 @@
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 
 pub use module::raw_set_handle_inheritable;
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = module::make_module(vm);
     super::os::extend_module(vm, &module);
     module

vm/src/stdlib/os.rs

@@ -1,9 +1,9 @@
 use crate::{
-    builtins::{PyBaseExceptionRef, PySet},
+    builtins::{PyBaseExceptionRef, PyModule, PySet},
     common::crt_fd::Fd,
     convert::IntoPyException,
     function::{ArgumentError, FromArgs, FsPath, FuncArgs},
-    AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
+    AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
 };
 use std::{
     ffi, fs, io,
@@ -1706,7 +1706,7 @@ impl SupportFunc {
     }
 }
 
-pub fn extend_module(vm: &VirtualMachine, module: &PyObject) {
+pub fn extend_module(vm: &VirtualMachine, module: &Py<PyModule>) {
     _os::extend_module(vm, module);
 
     let support_funcs = _os::support_funcs();

vm/src/stdlib/posix.rs

@@ -1,4 +1,4 @@
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 use std::os::unix::io::RawFd;
 
 pub fn raw_set_inheritable(fd: RawFd, inheritable: bool) -> nix::Result<()> {
@@ -12,7 +12,7 @@ pub fn raw_set_inheritable(fd: RawFd, inheritable: bool) -> nix::Result<()> {
     Ok(())
 }
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = module::make_module(vm);
     super::os::extend_module(vm, &module);
     module

vm/src/stdlib/posix_compat.rs

@@ -1,8 +1,8 @@
 //! `posix` compatible module for `not(any(unix, windows))`
 
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyObjectRef, PyRef, VirtualMachine};
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = module::make_module(vm);
     super::os::extend_module(vm, &module);
     module

vm/src/stdlib/signal.rs

@@ -1,6 +1,6 @@
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _signal::make_module(vm);
 
     _signal::init_signal_handlers(&module, vm);
@@ -11,8 +11,9 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
 #[pymodule]
 pub(crate) mod _signal {
     use crate::{
+        builtins::PyModule,
         convert::{IntoPyException, TryFromBorrowedObject},
-        signal, PyObjectRef, PyResult, VirtualMachine,
+        signal, Py, PyObjectRef, PyResult, VirtualMachine,
     };
     use std::sync::atomic::{self, Ordering};
 
@@ -80,7 +81,7 @@ pub(crate) mod _signal {
     #[pyattr]
     use libc::{SIGPWR, SIGSTKFLT};
 
-    pub(super) fn init_signal_handlers(module: &PyObjectRef, vm: &VirtualMachine) {
+    pub(super) fn init_signal_handlers(module: &Py<PyModule>, vm: &VirtualMachine) {
         let sig_dfl = vm.new_pyobj(SIG_DFL as u8);
         let sig_ign = vm.new_pyobj(SIG_IGN as u8);
 

vm/src/stdlib/sys.rs

@@ -1,4 +1,4 @@
-use crate::{convert::ToPyObject, PyObject, PyResult, VirtualMachine};
+use crate::{builtins::PyModule, convert::ToPyObject, Py, PyResult, VirtualMachine};
 
 pub(crate) use sys::{UnraisableHookArgs, MAXSIZE, MULTIARCH};
 
@@ -916,13 +916,15 @@ mod sys {
     impl UnraisableHookArgs {}
 }
 
-pub(crate) fn init_module(vm: &VirtualMachine, module: &PyObject, builtins: &PyObject) {
+pub(crate) fn init_module(vm: &VirtualMachine, module: &Py<PyModule>, builtins: &Py<PyModule>) {
     sys::extend_module(vm, module);
 
     let modules = vm.ctx.new_dict();
-    modules.set_item("sys", module.to_owned(), vm).unwrap();
     modules
-        .set_item("builtins", builtins.to_owned(), vm)
+        .set_item("sys", module.to_owned().into(), vm)
+        .unwrap();
+    modules
+        .set_item("builtins", builtins.to_owned().into(), vm)
         .unwrap();
     extend_module!(vm, module, {
         "__doc__" => sys::DOC.to_owned().to_pyobject(vm),

vm/src/stdlib/time.rs

@@ -2,11 +2,11 @@
 
 // See also:
 // https://docs.python.org/3/library/time.html
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 
 pub use time::*;
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = time::make_module(vm);
     #[cfg(unix)]
     unix::extend_module(vm, &module);

vm/src/stdlib/winreg.rs

@@ -1,13 +1,13 @@
 #![allow(non_snake_case)]
 
-use crate::{PyObjectRef, VirtualMachine};
+use crate::{builtins::PyModule, PyRef, VirtualMachine};
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = winreg::make_module(vm);
 
     macro_rules! add_constants {
         ($($name:ident),*$(,)?) => {
-            extend_module!(vm, module, {
+            extend_module!(vm, &module, {
                 $((stringify!($name)) => vm.new_pyobj(::winreg::enums::$name as usize)),*
             })
         };

vm/src/vm/mod.rs

@@ -244,7 +244,7 @@ impl VirtualMachine {
         // add the current directory to sys.path
         self.state_mut().settings.path_list.insert(0, "".to_owned());
 
-        stdlib::builtins::make_module(self, self.builtins.clone().into());
+        stdlib::builtins::init_module(self, &self.builtins);
         stdlib::sys::init_module(self, self.sys_module.as_ref(), self.builtins.as_ref());
 
         let mut essential_init = || -> PyResult {
@@ -794,12 +794,12 @@ impl VirtualMachine {
     #[doc(hidden)]
     pub fn __module_set_attr(
         &self,
-        module: &PyObject,
+        module: &Py<PyModule>,
         attr_name: &str,
         attr_value: impl Into<PyObjectRef>,
     ) -> PyResult<()> {
         let val = attr_value.into();
-        module.generic_setattr(
+        module.as_object().generic_setattr(
             self.ctx.intern_str(attr_name),
             PySetterValue::Assign(val),
             self,

vm/src/vm/vm_new.rs

@@ -20,7 +20,7 @@ impl VirtualMachine {
         value.into_pytuple(self)
     }
 
-    pub fn new_module(&self, name: &str, dict: PyDictRef, doc: Option<&str>) -> PyObjectRef {
+    pub fn new_module(&self, name: &str, dict: PyDictRef, doc: Option<&str>) -> PyRef<PyModule> {
         let module = PyRef::new_ref(
             PyModule {},
             self.ctx.types.module_type.to_owned(),
@@ -32,7 +32,7 @@ impl VirtualMachine {
                 .unwrap_or_else(|| self.ctx.none()),
             self,
         );
-        module.into()
+        module
     }
 
     pub fn new_scope_with_builtins(&self) -> Scope {

wasm/lib/src/vm_class.rs

@@ -5,8 +5,10 @@ use crate::{
 };
 use js_sys::{Object, TypeError};
 use rustpython_vm::{
-    builtins::PyWeak, compiler::Mode, scope::Scope, Interpreter, PyObjectRef, PyPayload, PyRef,
-    PyResult, Settings, VirtualMachine,
+    builtins::{PyModule, PyWeak},
+    compiler::Mode,
+    scope::Scope,
+    Interpreter, PyObjectRef, PyPayload, PyRef, PyResult, Settings, VirtualMachine,
 };
 use std::{
     cell::RefCell,
@@ -26,10 +28,10 @@ pub(crate) struct StoredVirtualMachine {
 #[pymodule]
 mod _window {}
 
-fn init_window_module(vm: &VirtualMachine) -> PyObjectRef {
+fn init_window_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _window::make_module(vm);
 
-    extend_module!(vm, module, {
+    extend_module!(vm, &module, {
         "window" => js_module::PyJsValue::new(wasm_builtins::window()).into_ref(&vm.ctx),
     });
 
@@ -300,7 +302,7 @@ impl WASMVirtualMachine {
             let module = vm.new_module(&name, attrs, None);
 
             let sys_modules = vm.sys_module.get_attr("modules", vm).into_js(vm)?;
-            sys_modules.set_item(&name, module, vm).into_js(vm)?;
+            sys_modules.set_item(&name, module.into(), vm).into_js(vm)?;
 
             Ok(())
         })?
@@ -313,13 +315,15 @@ impl WASMVirtualMachine {
             for entry in convert::object_entries(&module) {
                 let (key, value) = entry?;
                 let key = Object::from(key).to_string();
-                extend_module!(vm, py_module, {
+                extend_module!(vm, &py_module, {
                     &String::from(key) => convert::js_to_py(vm, value),
                 });
             }
 
             let sys_modules = vm.sys_module.get_attr("modules", vm).into_js(vm)?;
-            sys_modules.set_item(&name, py_module, vm).into_js(vm)?;
+            sys_modules
+                .set_item(&name, py_module.into(), vm)
+                .into_js(vm)?;
 
             Ok(())
         })?