Add delattr builtin method.

Author: windelbouwman

vm/src/builtins.rs

@@ -125,7 +125,14 @@ fn builtin_compile(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     compile::compile(vm, &source, mode, None)
 }
 
-// builtin_delattr
+fn builtin_delattr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [(obj, None), (attr, Some(vm.ctx.str_type()))]
+    );
+    vm.del_attr(obj, attr.clone())
+}
 
 fn builtin_dir(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     if args.args.is_empty() {
@@ -506,12 +513,9 @@ fn builtin_setattr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         args,
         required = [(obj, None), (attr, Some(vm.ctx.str_type())), (value, None)]
     );
-    if let PyObjectKind::String { value: ref name } = attr.borrow().kind {
-        obj.clone().set_attr(name, value.clone());
-        Ok(vm.get_none())
-    } else {
-        panic!("argument checking failure: attr not string")
-    }
+    let name = objstr::get_value(attr);
+    obj.clone().set_attr(&name, value.clone());
+    Ok(vm.get_none())
 }
 
 // builtin_slice
@@ -540,6 +544,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("chr"), ctx.new_rustfunc(builtin_chr));
     dict.insert(String::from("compile"), ctx.new_rustfunc(builtin_compile));
     dict.insert(String::from("complex"), ctx.complex_type());
+    dict.insert(String::from("delattr"), ctx.new_rustfunc(builtin_delattr));
     dict.insert(String::from("dict"), ctx.dict_type());
     dict.insert(String::from("divmod"), ctx.new_rustfunc(builtin_divmod));
     dict.insert(String::from("dir"), ctx.new_rustfunc(builtin_dir));

vm/src/frame.rs

@@ -1021,7 +1021,7 @@ impl Frame {
     fn delete_attr(&mut self, vm: &mut VirtualMachine, attr_name: &str) -> FrameResult {
         let parent = self.pop_value();
         let name = vm.ctx.new_str(attr_name.to_string());
-        vm.call_method(&parent, "__delattr__", vec![name])?;
+        vm.del_attr(&parent, name)?;
         Ok(None)
     }
 

vm/src/import.rs

@@ -30,26 +30,18 @@ fn import_uncached_module(
     let source = parser::read_file(filepath.as_path())
         .map_err(|e| vm.new_exception(import_error.clone(), e))?;
 
-    let code_obj = match compile::compile(
+    let code_obj = compile::compile(
         vm,
         &source,
         compile::Mode::Exec,
         Some(filepath.to_str().unwrap().to_string()),
-    ) {
-        Ok(bytecode) => {
-            debug!("Code object: {:?}", bytecode);
-            bytecode
-        }
-        Err(value) => return Err(value),
-    };
+    )?;
+    debug!("Code object: {:?}", code_obj);
 
     let builtins = vm.get_builtin_scope();
     let scope = vm.ctx.new_scope(Some(builtins));
     scope.set_item(&"__name__".to_string(), vm.new_str(module.to_string()));
-    match vm.run_code_obj(code_obj, scope.clone()) {
-        Ok(_) => {}
-        Err(value) => return Err(value),
-    }
+    vm.run_code_obj(code_obj, scope.clone())?;
     Ok(vm.ctx.new_module(module, scope))
 }
 

vm/src/obj/objtype.rs

@@ -116,10 +116,7 @@ pub fn type_call(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     debug!("type_call: {:?}", args);
     let typ = args.shift();
     let new = typ.get_attr("__new__").unwrap();
-    let obj = match vm.invoke(new, args.insert(typ.clone())) {
-        Ok(res) => res,
-        Err(err) => return Err(err),
-    };
+    let obj = vm.invoke(new, args.insert(typ.clone()))?;
 
     if let Some(init) = obj.typ().get_attr("__init__") {
         let res = vm.invoke(init, args.insert(obj.clone()))?;

vm/src/vm.rs

@@ -420,6 +420,10 @@ impl VirtualMachine {
         self.call_method(&obj, "__getattribute__", vec![attr_name])
     }
 
+    pub fn del_attr(&mut self, obj: &PyObjectRef, attr_name: PyObjectRef) -> PyResult {
+        self.call_method(&obj, "__delattr__", vec![attr_name])
+    }
+
     // get_method should be used for internal access to magic methods (by-passing
     // the full getattribute look-up.
     pub fn get_method(&mut self, obj: PyObjectRef, method_name: &str) -> PyResult {