Address feedback, simplify compilation code

Author: coolreader18

compiler/src/compile.rs

@@ -300,8 +300,17 @@ impl<O: OutputStream> Compiler<O> {
             Import { names } => {
                 // import a, b, c as d
                 for name in names {
-                    self.compile_import(Some(&name.symbol), vec![], 0, name.alias.is_some());
+                    self.emit(Instruction::Import {
+                        name: Some(name.symbol.clone()),
+                        symbols: vec![],
+                        level: 0,
+                    });
                     if let Some(alias) = &name.alias {
+                        for part in name.symbol.split('.').skip(1) {
+                            self.emit(Instruction::LoadAttr {
+                                name: part.to_owned(),
+                            });
+                        }
                         self.store_name(alias);
                     } else {
                         self.store_name(name.symbol.split('.').next().unwrap());
@@ -317,25 +326,23 @@ impl<O: OutputStream> Compiler<O> {
 
                 if import_star {
                     // from .... import *
-                    self.compile_import(
-                        module.as_ref().map(String::as_str),
-                        vec!["*".to_owned()],
-                        *level,
-                        false,
-                    );
+                    self.emit(Instruction::Import {
+                        name: module.clone(),
+                        symbols: vec!["*".to_owned()],
+                        level: *level,
+                    });
                     self.emit(Instruction::ImportStar);
                 } else {
                     // from mod import a, b as c
                     // First, determine the fromlist (for import lib):
                     let from_list = names.iter().map(|n| n.symbol.clone()).collect();
 
                     // Load module once:
-                    self.compile_import(
-                        module.as_ref().map(String::as_str),
-                        from_list,
-                        *level,
-                        false,
-                    );
+                    self.emit(Instruction::Import {
+                        name: module.clone(),
+                        symbols: from_list,
+                        level: *level,
+                    });
 
                     for name in names {
                         // import symbol from module:
@@ -573,30 +580,6 @@ impl<O: OutputStream> Compiler<O> {
         Ok(())
     }
 
-    fn compile_import(
-        &mut self,
-        name: Option<&str>,
-        symbols: Vec<String>,
-        level: usize,
-        get_final_module: bool,
-    ) {
-        self.emit(Instruction::Import {
-            name: name.map(ToOwned::to_owned),
-            symbols,
-            level,
-        });
-
-        if get_final_module {
-            if let Some(name) = name {
-                for part in name.split('.').skip(1) {
-                    self.emit(Instruction::LoadAttr {
-                        name: part.to_owned(),
-                    });
-                }
-            }
-        }
-    }
-
     fn compile_delete(&mut self, expression: &ast::Expression) -> Result<(), CompileError> {
         match &expression.node {
             ast::ExpressionType::Identifier { name } => {

vm/src/obj/objmodule.rs

@@ -28,14 +28,13 @@ impl PyModuleRef {
     }
 
     fn getattribute(self, name: PyStringRef, vm: &VirtualMachine) -> PyResult {
-        match vm.generic_getattribute(self.as_object().clone(), name.clone()) {
-            Ok(Some(val)) => Ok(val),
-            Ok(None) => Err(vm.new_attribute_error(format!(
-                "module '{}' has no attribute '{}'",
-                self.name, name,
-            ))),
-            Err(err) => Err(err),
-        }
+        vm.generic_getattribute(self.as_object().clone(), name.clone())?
+            .ok_or_else(|| {
+                vm.new_attribute_error(format!(
+                    "module '{}' has no attribute '{}'",
+                    self.name, name,
+                ))
+            })
     }
 
     fn repr(self, vm: &VirtualMachine) -> PyResult {

vm/src/obj/objobject.rs

@@ -225,9 +225,6 @@ fn object_dict_setter(
 
 fn object_getattribute(obj: PyObjectRef, name: PyStringRef, vm: &VirtualMachine) -> PyResult {
     vm_trace!("object.__getattribute__({:?}, {:?})", obj, name);
-    match vm.generic_getattribute(obj.clone(), name.clone()) {
-        Ok(Some(val)) => Ok(val),
-        Ok(None) => Err(vm.new_attribute_error(format!("{} has no attribute '{}'", obj, name))),
-        Err(err) => Err(err),
-    }
+    vm.generic_getattribute(obj.clone(), name.clone())?
+        .ok_or_else(|| vm.new_attribute_error(format!("{} has no attribute '{}'", obj, name)))
 }

vm/src/vm.rs

@@ -415,13 +415,13 @@ impl VirtualMachine {
 
         let module = self.new_str(module.to_owned());
 
-        let sys_module = if weird {
+        let cached_module = if weird {
             None
         } else {
             let sys_modules = self.get_attribute(self.sys_module.clone(), "modules")?;
             sys_modules.get_item(module.clone(), self).ok()
         };
-        match sys_module {
+        match cached_module {
             Some(module) => Ok(module),
             None => {
                 let import_func = self