Magic methods aren't looked up via getattribute.

cthulahoops · cthulahoops · commit 5c7b0da2f1f7 · 2018-11-01T19:57:13.000Z
diff --git a/vm/src/obj/objobject.rs b/vm/src/obj/objobject.rs
@@ -145,18 +145,7 @@ fn object_getattribute(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     if let Some(obj_attr) = obj.get_attr(&name) {
         Ok(obj_attr)
     } else if let Some(attr) = cls.get_attr(&name) {
-        let attr_class = attr.typ();
-        if let Some(descriptor) = attr_class.get_attr("__get__") {
-            vm.invoke(
-                descriptor,
-                PyFuncArgs {
-                    args: vec![attr, obj.clone(), cls],
-                    kwargs: vec![],
-                },
-            )
-        } else {
-            Ok(attr)
-        }
+        vm.call_get_descriptor(attr, obj.clone())
     } else {
         if let Some(getter) = cls.get_attr("__getattr__") {
             vm.invoke(
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -4,6 +4,7 @@ use super::super::pyobject::{
 };
 use super::super::vm::VirtualMachine;
 use super::objdict;
+use super::objstr;
 use super::objtype; // Required for arg_check! to use isinstance
 use std::collections::HashMap;
 
@@ -137,34 +138,70 @@ pub fn type_call(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> PyResult {
     Ok(obj)
 }
 
-// pub fn get_attribute(vm: &mut VirtualMachine, obj: PyObjectRef, name: &str) -> PyResult {
-//     let cls = obj.typ();
-//     trace!("get_attribute: {:?}, {:?}, {:?}", cls, obj, name);
-//     if let Some(attr) = cls.get_attr(name) {
-//         let attr_class = attr.typ();
-//         if let Some(descriptor) = attr_class.get_attr("__get__") {
-//             return vm.invoke(
-//                 descriptor,
-//                 PyFuncArgs {
-//                     args: vec![attr, obj, cls],
-//                     kwargs: vec![],
-//                 },
-//             );
-//         }
-//     }
-
-//     if let Some(obj_attr) = obj.get_attr(name) {
-//         Ok(obj_attr)
-//     } else if let Some(cls_attr) = cls.get_attr(name) {
-//         Ok(cls_attr)
-//     } else {
-//         let attribute_error = vm.context().exceptions.attribute_error.clone();
-//         Err(vm.new_exception(
-//             attribute_error,
-//             format!("{:?} object has no attribute {}", cls, name),
-//         ))
-//     }
-// }
+pub fn type_getattribute(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(
+        vm,
+        args,
+        required = [
+            (cls, Some(vm.ctx.object())),
+            (name_str, Some(vm.ctx.str_type()))
+        ]
+    );
+    let name = objstr::get_value(&name_str);
+    trace!("type.__getattribute__({:?}, {:?})", cls, name);
+    let mcl = cls.typ();
+
+    if let Some(attr) = mcl.get_attr(&name) {
+        let attr_class = attr.typ();
+        if attr_class.has_attr("__set__") {
+            if let Some(descriptor) = attr_class.get_attr("__get__") {
+                return vm.invoke(
+                    descriptor,
+                    PyFuncArgs {
+                        args: vec![attr, cls.clone(), mcl],
+                        kwargs: vec![],
+                    },
+                );
+            }
+        }
+    }
+
+    if let Some(attr) = cls.get_attr(&name) {
+        let attr_class = attr.typ();
+        if let Some(descriptor) = attr_class.get_attr("__get__") {
+            let none = vm.get_none();
+            return vm.invoke(
+                descriptor,
+                PyFuncArgs {
+                    args: vec![attr, none, cls.clone()],
+                    kwargs: vec![],
+                },
+            );
+        }
+    }
+
+    if let Some(cls_attr) = cls.get_attr(&name) {
+        Ok(cls_attr)
+    } else if let Some(attr) = mcl.get_attr(&name) {
+        vm.call_get_descriptor(attr, cls.clone())
+    } else {
+        if let Some(getter) = cls.get_attr("__getattr__") {
+            vm.invoke(
+                getter,
+                PyFuncArgs {
+                    args: vec![mcl, name_str.clone()],
+                    kwargs: vec![],
+                },
+            )
+        } else {
+            let attribute_error = vm.context().exceptions.attribute_error.clone();
+            Err(vm.new_exception(
+                attribute_error,
+                format!("{:?} object {:?} has no attribute {}", mcl, cls, name),
+            ))
+        }
+    }
+}
 
 pub fn get_attributes(obj: &PyObjectRef) -> HashMap<String, PyObjectRef> {
     // Gather all members here:
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -14,7 +14,6 @@ use super::frame::{copy_code, Frame};
 use super::obj::objgenerator;
 use super::obj::objiter;
 use super::obj::objlist;
-use super::obj::objobject;
 use super::obj::objtuple;
 use super::obj::objtype;
 use super::pyobject::{
@@ -150,18 +149,37 @@ impl VirtualMachine {
         self.call_method(obj, "__repr__", vec![])
     }
 
+    pub fn call_get_descriptor(&mut self, attr: PyObjectRef, obj: PyObjectRef) -> PyResult {
+        let attr_class = attr.typ();
+        if let Some(descriptor) = attr_class.get_attr("__get__") {
+            let cls = obj.typ();
+            self.invoke(
+                descriptor,
+                PyFuncArgs {
+                    args: vec![attr, obj.clone(), cls],
+                    kwargs: vec![],
+                },
+            )
+        } else {
+            Ok(attr)
+        }
+    }
+
     pub fn call_method(
         &mut self,
         obj: &PyObjectRef,
         method_name: &str,
         args: Vec<PyObjectRef>,
     ) -> PyResult {
-        let func = self.get_attribute(obj.clone(), method_name)?;
+        let cls = obj.typ();
+        let func = cls.get_attr(method_name).unwrap();
+        trace!("vm.call_method {:?} {:?} -> {:?}", obj, method_name, func);
+        let wrapped = self.call_get_descriptor(func, obj.clone())?;
         let args = PyFuncArgs {
             args: args,
             kwargs: vec![],
         };
-        self.invoke(func, args)
+        self.invoke(wrapped, args)
     }
 
     pub fn invoke(&mut self, func_ref: PyObjectRef, args: PyFuncArgs) -> PyResult {
@@ -177,18 +195,12 @@ impl VirtualMachine {
                 name: _,
                 dict: _,
                 mro: _,
-            } => {
-                let function = self.get_attribute(func_ref.clone(), "__call__")?;
-                self.invoke(function, args)
-            }
+            } => self.call_method(&func_ref, "__call__", args.args),
             PyObjectKind::BoundMethod {
                 ref function,
                 ref object,
             } => self.invoke(function.clone(), args.insert(object.clone())),
-            PyObjectKind::Instance { .. } => {
-                let function = self.get_attribute(func_ref.clone(), "__call__")?;
-                self.invoke(function, args)
-            }
+            PyObjectKind::Instance { .. } => self.call_method(&func_ref, "__call__", args.args),
             ref kind => {
                 unimplemented!("invoke unimplemented for: {:?}", kind);
             }
