Support mutual importing modules.

Author: windelbouwman

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,17 +11,21 @@ use crate::pyobject::{ItemProtocol, PyResult};
 use crate::util;
 use crate::vm::VirtualMachine;
 
-fn import_uncached_module(vm: &VirtualMachine, current_path: PathBuf, module: &str) -> PyResult {
+fn import_uncached_module(
+    vm: &VirtualMachine,
+    current_path: PathBuf,
+    module_name: &str,
+) -> PyResult {
     // Check for Rust-native modules
-    if let Some(module) = vm.stdlib_inits.borrow().get(module) {
+    if let Some(module) = vm.stdlib_inits.borrow().get(module_name) {
         return Ok(module(vm).clone());
     }
 
     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)
+    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()))?;
@@ -35,19 +39,25 @@ fn import_uncached_module(vm: &VirtualMachine, current_path: PathBuf, module: &s
     // 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))
+    attrs.set_item("__name__", vm.new_str(module_name.to_string()), vm)?;
+    let module = vm.ctx.new_module(module_name, attrs.clone());
+
+    // Store module in cache to prevent infinite loop with mutual importing libs:
+    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap();
+    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)
 }
 
 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")?;
+    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap();
     if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
         return Ok(module);
     }
     let module = import_uncached_module(vm, current_path, module_name)?;
-    sys_modules.set_item(module_name, module.clone(), vm)?;
     Ok(module)
 }