Merge pull request #67 from RustPython/mro

windelbouwman · web-flow · commit aa963dcbd294 · 2018-08-20T20:28:49.000+02:00
Compute Method Resolution Order (MRO).
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
@@ -81,6 +81,7 @@ pub enum Statement {
     ClassDef {
         name: String,
         body: Vec<Statement>,
+        args: Vec<String>,
         // TODO: docstring: String,
     },
     FunctionDef {
diff --git a/parser/src/parser.rs b/parser/src/parser.rs
@@ -175,11 +175,12 @@ mod tests {
 
     #[test]
     fn test_parse_class() {
-        let source = String::from("class Foo:\n def __init__(self):\n  pass\n");
+        let source = String::from("class Foo(A, B):\n def __init__(self):\n  pass\n");
         assert_eq!(
             parse_statement(&source),
             Ok(ast::Statement::ClassDef {
                 name: String::from("Foo"),
+                args: vec![String::from("A"), String::from("B")],
                 body: vec![ast::Statement::FunctionDef {
                     name: String::from("__init__"),
                     args: vec![String::from("self")],
diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
@@ -208,8 +208,9 @@ TypedArgsList: Vec<String> = {
 };
 
 ClassDef: ast::Statement = {
-  "class" <n:Identifier> <_a:("(" ")")?> ":" <s:Suite> => ast::Statement::ClassDef {
+  "class" <n:Identifier> <a:Parameters?> ":" <s:Suite> => ast::Statement::ClassDef {
 	  name: n,
+	  args: a.unwrap_or(vec![]),
 	  body: s},
 };
 
diff --git a/tests/snippets/mro.py b/tests/snippets/mro.py
@@ -0,0 +1,20 @@
+class X():
+    pass
+
+class Y():
+    pass
+
+class A(X, Y):
+    pass
+
+print(A.__mro__)
+
+class B(X, Y):
+    pass
+
+print(B.__mro__)
+
+class C(A, B):
+    pass
+
+print(C.__mro__)
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -270,7 +270,7 @@ fn builtin_range(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         PyObjectKind::Integer { ref value } => {
             let range_elements: Vec<PyObjectRef> =
                 (0..*value).map(|num| vm.context().new_int(num)).collect();
-            Ok(vm.context().new_list(Some(range_elements)))
+            Ok(vm.context().new_list(range_elements))
         }
         _ => panic!("first argument to range must be an integer"),
     }
@@ -372,13 +372,15 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     obj
 }
 
-pub fn builtin_build_class_(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    let function = args.args[0].clone();
-    let a1 = &*args.args[1].borrow();
-    let name = match &a1.kind {
-        PyObjectKind::String { value: name } => name,
-        _ => panic!("Class name must be a string."),
+pub fn builtin_build_class_(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
+    let function = args.shift();
+    let name_arg = args.shift();
+    let name = match name_arg.borrow().kind {
+        PyObjectKind::String { ref value } => value.to_string(),
+        _ => panic!("Class name must by a string!"),
     };
+    let mut bases = args.args.clone();
+    bases.push(vm.context().object.clone());
     let metaclass = vm.get_type();
     let namespace = vm.new_dict();
     &vm.invoke(
@@ -387,10 +389,5 @@ pub fn builtin_build_class_(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResu
             args: vec![namespace.clone()],
         },
     );
-    objtype::new(
-        metaclass,
-        name.to_string(),
-        vec![vm.get_object()],
-        namespace,
-    )
+    objtype::new(metaclass, name, bases, namespace)
 }
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -257,7 +257,7 @@ impl Compiler {
                     name: name.to_string(),
                 });
             }
-            ast::Statement::ClassDef { name, body } => {
+            ast::Statement::ClassDef { name, body, args } => {
                 self.emit(Instruction::LoadBuildClass);
                 self.code_object_stack
                     .push(CodeObject::new(vec![String::from("__locals__")]));
@@ -288,7 +288,13 @@ impl Compiler {
                         value: name.clone(),
                     },
                 });
-                self.emit(Instruction::CallFunction { count: 2 });
+
+                for base in args {
+                    self.emit(Instruction::LoadName { name: base.clone() });
+                }
+                self.emit(Instruction::CallFunction {
+                    count: 2 + args.len(),
+                });
 
                 self.emit(Instruction::StoreName {
                     name: name.to_string(),
diff --git a/vm/src/objclass.rs b/vm/src/objclass.rs
@@ -8,7 +8,6 @@ pub fn new_instance(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     let type_ref = args.shift();
     let dict = vm.new_dict();
     let obj = PyObject::new(PyObjectKind::Instance { dict: dict }, type_ref.clone());
-    // TODO Raise TypeError if init returns not None.
     Ok(obj)
 }
 
diff --git a/vm/src/objfunction.rs b/vm/src/objfunction.rs
@@ -1,4 +1,7 @@
-use super::pyobject::{PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult};
+use super::objtype;
+use super::pyobject::{
+    AttributeProtocol, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult,
+};
 use super::vm::VirtualMachine;
 use std::collections::HashMap;
 
@@ -40,3 +43,29 @@ pub fn create_bound_method_type(type_type: PyObjectRef) -> PyObjectRef {
 fn bind_method(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.new_bound_method(args.args[0].clone(), args.args[1].clone()))
 }
+
+pub fn create_member_descriptor_type(type_type: PyObjectRef, object: PyObjectRef) -> PyResult {
+    let mut dict = HashMap::new();
+
+    dict.insert(
+        String::from("__get__"),
+        PyObject::new(
+            PyObjectKind::RustFunction {
+                function: member_get,
+            },
+            type_type.clone(),
+        ),
+    );
+
+    objtype::new(
+        type_type.clone(),
+        String::from("member_descriptor"),
+        vec![object],
+        PyObject::new(PyObjectKind::Dict { elements: dict }, type_type.clone()),
+    )
+}
+
+fn member_get(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
+    let function = args.shift().get_attr(&String::from("function"));
+    vm.invoke(function, args)
+}
diff --git a/vm/src/objtype.rs b/vm/src/objtype.rs
@@ -1,6 +1,6 @@
 use super::pyobject::{
-    AttributeProtocol, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, ToRust,
-    TypeProtocol,
+    AttributeProtocol, IdProtocol, PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef,
+    PyResult, ToRust, TypeProtocol,
 };
 use super::vm::VirtualMachine;
 use std::collections::HashMap;
@@ -30,33 +30,62 @@ pub fn create_type() -> PyObjectRef {
     typ
 }
 
-pub fn type_type_add_methods(type_type: PyObjectRef, function_type: PyObjectRef) {
-    type_type.set_attr(
-        &String::from("__call__"),
-        PyObject::new(
-            PyObjectKind::RustFunction {
-                function: type_call,
-            },
-            function_type.clone(),
-        ),
+pub fn init(context: &mut PyContext) {
+    context
+        .type_type
+        .set_attr(&String::from("__call__"), context.new_rustfunc(type_call));
+    context
+        .type_type
+        .set_attr(&String::from("__new__"), context.new_rustfunc(type_new));
+
+    context.type_type.set_attr(
+        &String::from("__mro__"),
+        context.new_member_descriptor(type_mro),
+    );
+    context.type_type.set_attr(
+        &String::from("__class__"),
+        context.new_member_descriptor(type_new),
     );
-    type_type.set_attr(
-        &String::from("__new__"),
-        PyObject::new(
-            PyObjectKind::RustFunction { function: type_new },
-            function_type.clone(),
-        ),
+    context.type_type.set_attr(
+        &String::from("__dict__"),
+        context.new_member_descriptor(type_dict),
     );
 }
 
+fn type_mro(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    match _mro(args.args[0].clone()) {
+        Some(mro) => Ok(vm.context().new_tuple(mro)),
+        None => Err(vm.new_exception("Only classes have an MRO.".to_string())),
+    }
+}
+
+fn _mro(cls: PyObjectRef) -> Option<Vec<PyObjectRef>> {
+    match cls.borrow().kind {
+        PyObjectKind::Class { ref mro, .. } => {
+            let mut mro = mro.clone();
+            mro.insert(0, cls.clone());
+            Some(mro)
+        }
+        _ => None,
+    }
+}
+
+fn type_dict(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    match args.args[0].borrow().kind {
+        PyObjectKind::Class { ref dict, .. } => Ok(dict.clone()),
+        _ => Err(vm.new_exception("type_dict must be called on a class.".to_string())),
+    }
+}
+
 pub fn type_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     debug!("type.__new__{:?}", args);
     if args.args.len() == 2 {
         Ok(args.args[1].typ())
     } else if args.args.len() == 4 {
         let typ = args.args[0].clone();
         let name = args.args[1].to_str().unwrap();
-        let bases = args.args[2].to_vec().unwrap();
+        let mut bases = args.args[2].to_vec().unwrap();
+        bases.push(vm.context().object.clone());
         let dict = args.args[3].clone();
         new(typ, name, bases, dict)
     } else {
@@ -108,12 +137,61 @@ pub fn get_attribute(vm: &mut VirtualMachine, obj: PyObjectRef, name: &String) -
     }
 }
 
+fn take_next_base(
+    mut bases: Vec<Vec<PyObjectRef>>,
+) -> Option<(PyObjectRef, Vec<Vec<PyObjectRef>>)> {
+    let mut next = None;
+
+    bases = bases.into_iter().filter(|x| !x.is_empty()).collect();
+
+    for base in &bases {
+        let head = base[0].clone();
+        if !(&bases)
+            .into_iter()
+            .any(|x| x[1..].into_iter().any(|x| x.get_id() == head.get_id()))
+        {
+            next = Some(head);
+            break;
+        }
+    }
+
+    if let Some(head) = next {
+        for ref mut item in &mut bases {
+            if item[0].get_id() == head.get_id() {
+                item.remove(0);
+            }
+        }
+        return Some((head, bases));
+    }
+    None
+}
+
+fn linearise_mro(mut bases: Vec<Vec<PyObjectRef>>) -> Option<Vec<PyObjectRef>> {
+    debug!("Linearising MRO: {:?}", bases);
+    let mut result = vec![];
+    loop {
+        if (&bases).into_iter().all(|x| x.is_empty()) {
+            break;
+        }
+        match take_next_base(bases) {
+            Some((head, new_bases)) => {
+                result.push(head);
+                bases = new_bases;
+            }
+            None => return None,
+        }
+    }
+    Some(result)
+}
+
 pub fn new(typ: PyObjectRef, name: String, bases: Vec<PyObjectRef>, dict: PyObjectRef) -> PyResult {
+    let mros = bases.into_iter().map(|x| _mro(x).unwrap()).collect();
+    let mro = linearise_mro(mros).unwrap();
     Ok(PyObject::new(
         PyObjectKind::Class {
             name: name,
             dict: dict,
-            mro: bases,
+            mro: mro,
         },
         typ,
     ))
@@ -123,3 +201,51 @@ pub fn call(vm: &mut VirtualMachine, typ: PyObjectRef, args: PyFuncArgs) -> PyRe
     let function = get_attribute(vm, typ, &String::from("__call__"))?;
     vm.invoke(function, args)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{create_type, linearise_mro, new};
+    use super::{IdProtocol, PyContext, PyObjectRef};
+
+    fn map_ids(obj: Option<Vec<PyObjectRef>>) -> Option<Vec<usize>> {
+        match obj {
+            Some(vec) => Some(vec.into_iter().map(|x| x.get_id()).collect()),
+            None => None,
+        }
+    }
+
+    #[test]
+    fn test_linearise() {
+        let context = PyContext::new();
+        let object = context.object;
+        let type_type = create_type();
+
+        let a = new(
+            type_type.clone(),
+            String::from("A"),
+            vec![object.clone()],
+            type_type.clone(),
+        ).unwrap();
+        let b = new(
+            type_type.clone(),
+            String::from("B"),
+            vec![object.clone()],
+            type_type.clone(),
+        ).unwrap();
+
+        assert_eq!(
+            map_ids(linearise_mro(vec![
+                vec![object.clone()],
+                vec![object.clone()]
+            ])),
+            map_ids(Some(vec![object.clone()]))
+        );
+        assert_eq!(
+            map_ids(linearise_mro(vec![
+                vec![a.clone(), object.clone()],
+                vec![b.clone(), object.clone()],
+            ])),
+            map_ids(Some(vec![a.clone(), b.clone(), object.clone()]))
+        );
+    }
+}
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
diff --git a/vm/src/sysmodule.rs b/vm/src/sysmodule.rs
diff --git a/vm/src/vm.rs b/vm/src/vm.rs

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ pub fn new_instance(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {`
`8`	`8`	`let type_ref = args.shift();`
`9`	`9`	`let dict = vm.new_dict();`
`10`	`10`	`let obj = PyObject::new(PyObjectKind::Instance { dict: dict }, type_ref.clone());`
`11`		`- // TODO Raise TypeError if init returns not None.`
`12`	`11`	`Ok(obj)`
`13`	`12`	`}`
`14`	`13`