Merge pull request RustPython#841 from RustPython/mutual-import

Support mutual importing modules.

Author: cthulahoops

tests/snippets/import.py

@@ -3,6 +3,7 @@
 from import_target import func as aliased_func, other_func as aliased_other_func
 from import_star import *
 
+import import_mutual1
 assert import_target.X == import_target.func()
 assert import_target.X == func()
 

tests/snippets/import_mutual1.py

@@ -0,0 +1,4 @@
+
+# Mutual recursive import:
+import import_mutual2
+

tests/snippets/import_mutual2.py

@@ -0,0 +1,3 @@
+
+# Mutual recursive import:
+import import_mutual1

vm/src/import.rs

@@ -11,44 +11,47 @@ use crate::pyobject::{ItemProtocol, PyResult};
 use crate::util;
 use crate::vm::VirtualMachine;
 
-fn import_uncached_module(vm: &VirtualMachine, current_path: PathBuf, module: &str) -> PyResult {
-    // Check for Rust-native modules
-    if let Some(module) = vm.stdlib_inits.borrow().get(module) {
-        return Ok(module(vm).clone());
-    }
+pub fn import_module(vm: &VirtualMachine, current_path: PathBuf, module_name: &str) -> PyResult {
+    // Cached modules:
+    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap();
 
-    let notfound_error = vm.context().exceptions.module_not_found_error.clone();
-    let import_error = vm.context().exceptions.import_error.clone();
+    // First, see if we already loaded the module:
+    if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
+        Ok(module)
+    } else if let Some(make_module_func) = vm.stdlib_inits.borrow().get(module_name) {
+        let module = make_module_func(vm);
+        sys_modules.set_item(module_name, module.clone(), vm)?;
+        Ok(module)
+    } else {
+        let notfound_error = vm.context().exceptions.module_not_found_error.clone();
+        let import_error = vm.context().exceptions.import_error.clone();
 
-    // Time to search for module in any place:
-    let file_path = find_source(vm, current_path, module)
-        .map_err(|e| vm.new_exception(notfound_error.clone(), e))?;
-    let source = util::read_file(file_path.as_path())
-        .map_err(|e| vm.new_exception(import_error.clone(), e.to_string()))?;
-    let code_obj = compile::compile(
-        vm,
-        &source,
-        &compile::Mode::Exec,
-        file_path.to_str().unwrap().to_string(),
-    )
-    .map_err(|err| vm.new_syntax_error(&err))?;
-    // trace!("Code object: {:?}", code_obj);
+        // Time to search for module in any place:
+        let file_path = find_source(vm, current_path, module_name)
+            .map_err(|e| vm.new_exception(notfound_error.clone(), e))?;
+        let source = util::read_file(file_path.as_path())
+            .map_err(|e| vm.new_exception(import_error.clone(), e.to_string()))?;
+        let code_obj = compile::compile(
+            vm,
+            &source,
+            &compile::Mode::Exec,
+            file_path.to_str().unwrap().to_string(),
+        )
+        .map_err(|err| vm.new_syntax_error(&err))?;
+        // trace!("Code object: {:?}", code_obj);
 
-    let attrs = vm.ctx.new_dict();
-    attrs.set_item("__name__", vm.new_str(module.to_string()), vm)?;
-    vm.run_code_obj(code_obj, Scope::new(None, attrs.clone()))?;
-    Ok(vm.ctx.new_module(module, attrs))
-}
+        let attrs = vm.ctx.new_dict();
+        attrs.set_item("__name__", vm.new_str(module_name.to_string()), vm)?;
+        let module = vm.ctx.new_module(module_name, attrs.clone());
 
-pub fn import_module(vm: &VirtualMachine, current_path: PathBuf, module_name: &str) -> PyResult {
-    // First, see if we already loaded the module:
-    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules")?;
-    if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
-        return Ok(module);
+        // Store module in cache to prevent infinite loop with mutual importing libs:
+        sys_modules.set_item(module_name, module.clone(), vm)?;
+
+        // Execute main code in module:
+        vm.run_code_obj(code_obj, Scope::new(None, attrs))?;
+
+        Ok(module)
     }
-    let module = import_uncached_module(vm, current_path, module_name)?;
-    sys_modules.set_item(module_name, module.clone(), vm)?;
-    Ok(module)
 }
 
 fn find_source(vm: &VirtualMachine, current_path: PathBuf, name: &str) -> Result<PathBuf, String> {