Create workaround for properties on None

skinnyBat · skinnyBat · commit 08e66b5002f3 · 2019-03-20T19:58:56.000+13:00
diff --git a/vm/src/obj/objnone.rs b/vm/src/obj/objnone.rs
@@ -1,6 +1,9 @@
 use crate::function::PyFuncArgs;
+use crate::obj::objproperty::PyPropertyRef;
+use crate::obj::objstr::PyStringRef;
 use crate::pyobject::{
-    IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    AttributeProtocol, IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
+    TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -39,6 +42,57 @@ impl PyNoneRef {
     fn bool(self, _vm: &mut VirtualMachine) -> PyResult<bool> {
         Ok(false)
     }
+
+    fn get_attribute(self, name: PyStringRef, vm: &mut VirtualMachine) -> PyResult {
+        trace!("None.__getattribute__({:?}, {:?})", self, name);
+        let cls = self.typ().into_object();
+
+        // Properties use a comparision with None to determine if they are either invoked by am
+        // instance binding or a class binding. But if the object itself is None then this detection
+        // won't work. Instead we call a special function on property that bypasses this check, as
+        // we are invoking it as a instance binding.
+        //
+        // In CPython they instead call the slot tp_descr_get with NULL to indicates it's an
+        // instance binding.
+        // https://github.com/python/cpython/blob/master/Objects/typeobject.c#L3281
+        fn call_descriptor(
+            descriptor: PyObjectRef,
+            get_func: PyObjectRef,
+            obj: PyObjectRef,
+            cls: PyObjectRef,
+            vm: &mut VirtualMachine,
+        ) -> PyResult {
+            if let Ok(property) = PyPropertyRef::try_from_object(vm, descriptor.clone()) {
+                property.instance_binding_get(obj, vm)
+            } else {
+                vm.invoke(get_func, vec![descriptor, obj, cls])
+            }
+        }
+
+        if let Some(attr) = cls.get_attr(&name.value) {
+            let attr_class = attr.typ();
+            if attr_class.has_attr("__set__") {
+                if let Some(get_func) = attr_class.get_attr("__get__") {
+                    return call_descriptor(attr, get_func, self.into_object(), cls.clone(), vm);
+                }
+            }
+        }
+
+        if let Some(obj_attr) = self.as_object().get_attr(&name.value) {
+            Ok(obj_attr)
+        } else if let Some(attr) = cls.get_attr(&name.value) {
+            let attr_class = attr.typ();
+            if let Some(get_func) = attr_class.get_attr("__get__") {
+                call_descriptor(attr, get_func, self.into_object(), cls.clone(), vm)
+            } else {
+                Ok(attr)
+            }
+        } else if let Some(getter) = cls.get_attr("__getattr__") {
+            vm.invoke(getter, vec![self.into_object(), name.into_object()])
+        } else {
+            Err(vm.new_attribute_error(format!("{} has no attribute '{}'", self.as_object(), name)))
+        }
+    }
 }
 
 fn none_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -55,5 +109,6 @@ pub fn init(context: &PyContext) {
         "__new__" => context.new_rustfunc(none_new),
         "__repr__" => context.new_rustfunc(PyNoneRef::repr),
         "__bool__" => context.new_rustfunc(PyNoneRef::bool),
+        "__getattribute__" => context.new_rustfunc(PyNoneRef::get_attribute)
     });
 }
diff --git a/vm/src/obj/objproperty.rs b/vm/src/obj/objproperty.rs
@@ -68,6 +68,19 @@ impl PyPropertyRef {
 
     // Descriptor methods
 
+    // specialised version that doesn't check for None
+    pub(crate) fn instance_binding_get(
+        self,
+        obj: PyObjectRef,
+        vm: &mut VirtualMachine,
+    ) -> PyResult {
+        if let Some(getter) = self.getter.as_ref() {
+            vm.invoke(getter.clone(), obj)
+        } else {
+            Err(vm.new_attribute_error("unreadable attribute".to_string()))
+        }
+    }
+
     fn get(self, obj: PyObjectRef, _owner: PyClassRef, vm: &mut VirtualMachine) -> PyResult {
         if let Some(getter) = self.getter.as_ref() {
             if obj.is(&vm.ctx.none) {
