@@ -2,7 +2,7 @@ pub(crate) use gc::module_def;
 
 #[pymodule]
 mod gc {
-    use crate::vm::{PyObjectRef, PyResult, VirtualMachine, function::FuncArgs};
+    use crate::vm::{PyResult, VirtualMachine, function::FuncArgs};
 
     #[pyfunction]
     fn collect(_args: FuncArgs, _vm: &VirtualMachine) -> i32 {
@@ -40,15 +40,13 @@ mod gc {
     }
 
     #[pyfunction]
-    fn get_referents(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
-        // RustPython does not track object references.
-        vm.ctx.new_tuple(vec![]).into()
+    fn get_referents(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        Err(vm.new_not_implemented_error(""))
     }
 
     #[pyfunction]
-    fn get_referrers(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
-        // RustPython does not track object references.
-        vm.ctx.new_list(vec![]).into()
+    fn get_referrers(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        Err(vm.new_not_implemented_error(""))
     }
 
     #[pyfunction]
 
@@ -104,13 +104,8 @@ pub fn import_builtin(vm: &VirtualMachine, module_name: &str) -> PyResult {
         // Phase 1: Create module from definition
         let module = PyModule::from_def(def).into_ref(&vm.ctx);
 
-        // Initialize module dict
-        let dict = vm.ctx.new_dict();
-        dict.set_item("__name__", vm.ctx.new_str(def.name.as_str()).into(), vm)?;
-        if let Some(doc) = def.doc {
-            dict.set_item("__doc__", vm.ctx.new_str(doc.as_str()).into(), vm)?;
-        }
-        module.set_attr("__dict__", dict, vm)?;
+        // Initialize module dict using proper method
+        PyModule::__init_dict_from_def(vm, &module);
 
         // Add to sys.modules BEFORE exec (critical for circular import handling)
         sys_modules.set_item(module_name, module.clone().into(), vm)?;
 
@@ -135,13 +135,8 @@ mod _imp {
             // Phase 1: Create module from definition
             let module = PyModule::from_def(def).into_ref(&vm.ctx);
 
-            // Initialize module dict
-            let dict = vm.ctx.new_dict();
-            dict.set_item("__name__", vm.ctx.new_str(def.name.as_str()).into(), vm)?;
-            if let Some(doc) = def.doc {
-                dict.set_item("__doc__", vm.ctx.new_str(doc.as_str()).into(), vm)?;
-            }
-            module.set_attr("__dict__", dict, vm)?;
+            // Initialize module dict using proper method
+            PyModule::__init_dict_from_def(vm, &module);
 
             // Add to sys.modules BEFORE exec (critical for circular import handling)
             sys_modules.set_item(&*name, module.clone().into(), vm)?;
 
@@ -476,13 +476,15 @@ impl VirtualMachine {
     }
 
     /// Can only be used in the initialization closure passed to [`Interpreter::with_init`]
+    #[deprecated(note = "use add_native_module_def(s) with multi-phase module initialization")]
     pub fn add_native_module<S>(&mut self, name: S, module: stdlib::StdlibInitFunc)
     where
         S: Into<Cow<'static, str>>,
     {
         self.state_mut().module_inits.insert(name.into(), module);
     }
 
+    #[deprecated(note = "use add_native_module_defs with multi-phase module initialization")]
     pub fn add_native_modules<I>(&mut self, iter: I)
     where
         I: IntoIterator<Item = (Cow<'static, str>, stdlib::StdlibInitFunc)>,
Original file line number	Diff line number	Diff line change
`@@ -476,13 +476,15 @@ impl VirtualMachine {`
`476`	`476`	`}`
`477`	`477`
`478`	`478`	/// Can only be used in the initialization closure passed to [`Interpreter::with_init`]
	`479`	`+ #[deprecated(note = "use add_native_module_def(s) with multi-phase module initialization")]`
`479`	`480`	`pub fn add_native_module<S>(&mut self, name: S, module: stdlib::StdlibInitFunc)`
`480`	`481`	`where`
`481`	`482`	`S: Into<Cow<'static, str>>,`
`482`	`483`	`{`
`483`	`484`	`self.state_mut().module_inits.insert(name.into(), module);`
`484`	`485`	`}`
`485`	`486`
	`487`	`+ #[deprecated(note = "use add_native_module_defs with multi-phase module initialization")]`
`486`	`488`	`pub fn add_native_modules<I>(&mut self, iter: I)`
`487`	`489`	`where`
`488`	`490`	`I: IntoIterator<Item = (Cow<'static, str>, stdlib::StdlibInitFunc)>,`