Raise error if sys.module value is None

Author: palaviv

vm/src/frame.rs

@@ -780,7 +780,7 @@ impl ExecutingFrame<'_> {
         // Load attribute, and transform any error into import error.
         let obj = vm
             .get_attribute(module, name)
-            .map_err(|_| vm.new_import_error(format!("cannot import name '{}'", name)))?;
+            .map_err(|_| vm.new_import_error(format!("cannot import name '{}'", name), name))?;
         self.push_value(obj);
         Ok(None)
     }

vm/src/import.rs

@@ -60,15 +60,25 @@ pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
     vm.state
         .frozen
         .get(module_name)
-        .ok_or_else(|| vm.new_import_error(format!("Cannot import frozen module {}", module_name)))
+        .ok_or_else(|| {
+            vm.new_import_error(
+                format!("Cannot import frozen module {}", module_name),
+                module_name,
+            )
+        })
         .and_then(|frozen| import_codeobj(vm, module_name, frozen.code.clone(), false))
 }
 
 pub fn import_builtin(vm: &VirtualMachine, module_name: &str) -> PyResult {
     vm.state
         .stdlib_inits
         .get(module_name)
-        .ok_or_else(|| vm.new_import_error(format!("Cannot import bultin module {}", module_name)))
+        .ok_or_else(|| {
+            vm.new_import_error(
+                format!("Cannot import bultin module {}", module_name),
+                module_name,
+            )
+        })
         .and_then(|make_module_func| {
             let module = make_module_func(vm);
             let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules")?;

vm/src/stdlib/imp.rs

@@ -62,7 +62,10 @@ fn imp_get_frozen_object(name: PyStringRef, vm: &VirtualMachine) -> PyResult<PyC
             PyCode::new(frozen)
         })
         .ok_or_else(|| {
-            vm.new_import_error(format!("No such frozen object named {}", name.as_str()))
+            vm.new_import_error(
+                format!("No such frozen object named {}", name.as_str()),
+                name.as_str(),
+            )
         })
 }
 
@@ -76,7 +79,10 @@ fn imp_is_frozen_package(name: PyStringRef, vm: &VirtualMachine) -> PyResult<boo
         .get(name.as_str())
         .map(|frozen| frozen.package)
         .ok_or_else(|| {
-            vm.new_import_error(format!("No such frozen object named {}", name.as_str()))
+            vm.new_import_error(
+                format!("No such frozen object named {}", name.as_str()),
+                name.as_str(),
+            )
         })
 }
 

vm/src/vm.rs

@@ -556,9 +556,12 @@ impl VirtualMachine {
         syntax_error
     }
 
-    pub fn new_import_error(&self, msg: String) -> PyBaseExceptionRef {
+    pub fn new_import_error(&self, msg: String, name: &str) -> PyBaseExceptionRef {
         let import_error = self.ctx.exceptions.import_error.clone();
-        self.new_exception_msg(import_error, msg)
+        let exc = self.new_exception_msg(import_error, msg);
+        self.set_attr(exc.as_object(), "name", self.new_str(name.to_owned()))
+            .unwrap();
+        exc
     }
 
     pub fn new_runtime_error(&self, msg: String) -> PyBaseExceptionRef {
@@ -699,11 +702,22 @@ impl VirtualMachine {
         };
 
         match cached_module {
-            Some(module) => Ok(module),
+            Some(cached_module) => {
+                if self.is_none(&cached_module) {
+                    Err(self.new_import_error(
+                        format!("import of {} halted; None in sys.modules", module),
+                        module,
+                    ))
+                } else {
+                    Ok(cached_module)
+                }
+            }
             None => {
                 let import_func = self
                     .get_attribute(self.builtins.clone(), "__import__")
-                    .map_err(|_| self.new_import_error("__import__ not found".to_owned()))?;
+                    .map_err(|_| {
+                        self.new_import_error("__import__ not found".to_owned(), module)
+                    })?;
 
                 let (locals, globals) = if let Some(frame) = self.current_frame() {
                     (