Merge pull request RustPython#129 from RustPython/objtyp

Implement dir on object

Author: cthulahoops

vm/src/builtins.rs

@@ -32,14 +32,16 @@ fn dir_locals(vm: &mut VirtualMachine) -> PyObjectRef {
     get_locals(vm)
 }
 
-fn dir_object(vm: &mut VirtualMachine, _obj: PyObjectRef) -> PyObjectRef {
-    let d = vm.new_dict();
-    // TODO: loop over dict of instance, next of class?
-    // TODO: Implement dir for objects
-    // for i in obj.iter_items() {
-    //    d.set_item(k, v);
-    // }
-    d
+fn dir_object(vm: &mut VirtualMachine, obj: &PyObjectRef) -> PyObjectRef {
+    // Gather all members here:
+    let attributes = objtype::get_attributes(obj);
+    let mut members: Vec<String> = attributes.into_iter().map(|(n, _o)| n).collect();
+
+    // Sort members:
+    members.sort();
+
+    let members_pystr = members.into_iter().map(|m| vm.ctx.new_str(m)).collect();
+    vm.ctx.new_list(members_pystr)
 }
 
 // builtin_abs
@@ -115,7 +117,7 @@ fn builtin_dir(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         Ok(dir_locals(vm))
     } else {
         let obj = args.args.into_iter().next().unwrap();
-        Ok(dir_object(vm, obj))
+        Ok(dir_object(vm, &obj))
     }
 }
 

vm/src/obj/objbytes.rs

@@ -24,7 +24,7 @@ fn bytes_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let val = if objtype::isinstance(arg, vm.ctx.list_type()) {
         let mut data_bytes = vec![];
         for elem in objlist::get_elements(arg) {
-            let v = match objint::to_int(vm, &elem) {
+            let v = match objint::to_int(vm, &elem, 10) {
                 Ok(int_ref) => int_ref,
                 Err(err) => return Err(err),
             };

vm/src/obj/objint.rs

@@ -4,6 +4,7 @@ use super::super::pyobject::{
 };
 use super::super::vm::VirtualMachine;
 use super::objfloat;
+use super::objstr;
 use super::objtype;
 
 fn int_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -22,8 +23,11 @@ fn int_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     if !objtype::issubclass(cls, vm.ctx.int_type()) {
         return Err(vm.new_type_error(format!("{:?} is not a subtype of int", cls)));
     }
+
+    // TODO: extract kwargs:
+    let base = 10;
     let val = match val_option {
-        Some(val) => to_int(vm, val)?,
+        Some(val) => to_int(vm, val, base)?,
         None => 0,
     };
     Ok(PyObject::new(
@@ -33,13 +37,29 @@ fn int_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 }
 
 // Casting function:
-pub fn to_int(vm: &mut VirtualMachine, obj: &PyObjectRef) -> Result<i32, PyObjectRef> {
+pub fn to_int(vm: &mut VirtualMachine, obj: &PyObjectRef, base: u32) -> Result<i32, PyObjectRef> {
     let val = if objtype::isinstance(obj, vm.ctx.int_type()) {
         get_value(obj)
     } else if objtype::isinstance(obj, vm.ctx.float_type()) {
         objfloat::get_value(obj) as i32
+    } else if objtype::isinstance(obj, vm.ctx.str_type()) {
+        let s = objstr::get_value(obj);
+        match i32::from_str_radix(&s, base) {
+            Ok(v) => v,
+            Err(err) => {
+                trace!("Error occured during int conversion {:?}", err);
+                return Err(vm.new_value_error(format!(
+                    "invalid literal for int() with base {}: '{}'",
+                    base, s
+                )));
+            }
+        }
     } else {
-        return Err(vm.new_type_error("Cannot construct int".to_string()));
+        let type_name = objtype::get_type_name(&obj.typ());
+        return Err(vm.new_type_error(format!(
+            "int() argument must be a string or a number, not '{}'",
+            type_name
+        )));
     };
     Ok(val)
 }

vm/src/obj/objtype.rs

@@ -5,6 +5,7 @@ use super::super::pyobject::{
 use super::super::vm::VirtualMachine;
 use super::objdict;
 use super::objtype; // Required for arg_check! to use isinstance
+use std::collections::HashMap;
 
 /*
  * The magical type type
@@ -54,6 +55,10 @@ fn _mro(cls: PyObjectRef) -> Option<Vec<PyObjectRef>> {
     }
 }
 
+pub fn base_classes(obj: &PyObjectRef) -> Vec<PyObjectRef> {
+    _mro(obj.typ()).unwrap()
+}
+
 pub fn isinstance(obj: &PyObjectRef, cls: PyObjectRef) -> bool {
     let mro = _mro(obj.typ()).unwrap();
     mro.into_iter().any(|c| c.is(&cls))
@@ -161,6 +166,37 @@ pub fn get_attribute(vm: &mut VirtualMachine, obj: PyObjectRef, name: &str) -> P
     }
 }
 
+pub fn get_attributes(obj: &PyObjectRef) -> HashMap<String, PyObjectRef> {
+    // Gather all members here:
+    let mut attributes: HashMap<String, PyObjectRef> = HashMap::new();
+
+    // Get class attributes:
+    let mut base_classes = objtype::base_classes(obj);
+    base_classes.reverse();
+    for bc in base_classes {
+        if let PyObjectKind::Class {
+            name: _,
+            dict,
+            mro: _,
+        } = &bc.borrow().kind
+        {
+            let elements = objdict::get_elements(dict);
+            for (name, value) in elements {
+                attributes.insert(name.to_string(), value.clone());
+            }
+        }
+    }
+
+    // Get instance attributes:
+    if let PyObjectKind::Instance { dict } = &obj.borrow().kind {
+        let elements = objdict::get_elements(dict);
+        for (name, value) in elements {
+            attributes.insert(name.to_string(), value.clone());
+        }
+    }
+    attributes
+}
+
 fn take_next_base(
     mut bases: Vec<Vec<PyObjectRef>>,
 ) -> Option<(PyObjectRef, Vec<Vec<PyObjectRef>>)> {

vm/src/vm.rs

@@ -73,10 +73,15 @@ impl VirtualMachine {
     }
 
     pub fn new_type_error(&mut self, msg: String) -> PyObjectRef {
-        let type_error = self.context().exceptions.type_error.clone();
+        let type_error = self.ctx.exceptions.type_error.clone();
         self.new_exception(type_error, msg)
     }
 
+    pub fn new_value_error(&mut self, msg: String) -> PyObjectRef {
+        let value_error = self.ctx.exceptions.value_error.clone();
+        self.new_exception(value_error, msg)
+    }
+
     pub fn new_scope(&mut self) -> PyObjectRef {
         let parent_scope = self.current_frame_mut().locals.clone();
         self.ctx.new_scope(Some(parent_scope))