method

OddCoincidence · OddCoincidence · commit 5a74121c76a0 · 2019-03-09T07:11:28.000-08:00
diff --git a/vm/src/obj/objfunction.rs b/vm/src/obj/objfunction.rs
@@ -29,6 +29,25 @@ impl PyObjectPayload2 for PyFunction {
     }
 }
 
+#[derive(Debug)]
+pub struct PyMethod {
+    // TODO: these shouldn't be public
+    pub object: PyObjectRef,
+    pub function: PyObjectRef,
+}
+
+impl PyMethod {
+    pub fn new(object: PyObjectRef, function: PyObjectRef) -> Self {
+        PyMethod { object, function }
+    }
+}
+
+impl PyObjectPayload2 for PyMethod {
+    fn required_type(ctx: &PyContext) -> PyObjectRef {
+        ctx.bound_method_type()
+    }
+}
+
 pub fn init(context: &PyContext) {
     let function_type = &context.function_type;
     context.set_attr(&function_type, "__get__", context.new_rustfunc(bind_method));
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -24,7 +24,7 @@ use crate::obj::objenumerate;
 use crate::obj::objfilter;
 use crate::obj::objfloat::{self, PyFloat};
 use crate::obj::objframe;
-use crate::obj::objfunction::{self, PyFunction};
+use crate::obj::objfunction::{self, PyFunction, PyMethod};
 use crate::obj::objgenerator;
 use crate::obj::objint::{self, PyInt};
 use crate::obj::objiter;
@@ -666,7 +666,9 @@ impl PyContext {
 
     pub fn new_bound_method(&self, function: PyObjectRef, object: PyObjectRef) -> PyObjectRef {
         PyObject::new(
-            PyObjectPayload::BoundMethod { function, object },
+            PyObjectPayload::AnyRustValue {
+                value: Box::new(PyMethod::new(object, function)),
+            },
             self.bound_method_type(),
         )
     }
@@ -1511,10 +1513,6 @@ pub enum PyObjectPayload {
     Generator {
         frame: PyObjectRef,
     },
-    BoundMethod {
-        function: PyObjectRef,
-        object: PyObjectRef,
-    },
     WeakRef {
         referent: PyObjectWeakRef,
     },
@@ -1542,10 +1540,6 @@ impl fmt::Debug for PyObjectPayload {
             PyObjectPayload::Iterator { .. } => write!(f, "iterator"),
             PyObjectPayload::Slice { .. } => write!(f, "slice"),
             PyObjectPayload::Generator { .. } => write!(f, "generator"),
-            PyObjectPayload::BoundMethod {
-                ref function,
-                ref object,
-            } => write!(f, "bound-method: {:?} of {:?}", function, object),
             PyObjectPayload::RustFunction { .. } => write!(f, "rust function"),
             PyObjectPayload::Frame { .. } => write!(f, "frame"),
             PyObjectPayload::AnyRustValue { value } => value.fmt(f),
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -18,7 +18,7 @@ use crate::frame::{Scope, ScopeRef};
 use crate::obj::objbool;
 use crate::obj::objcode;
 use crate::obj::objframe;
-use crate::obj::objfunction::PyFunction;
+use crate::obj::objfunction::{PyFunction, PyMethod};
 use crate::obj::objgenerator;
 use crate::obj::objiter;
 use crate::obj::objlist::PyList;
@@ -298,12 +298,15 @@ impl VirtualMachine {
         {
             return self.invoke_python_function(code, scope, defaults, args);
         }
+        if let Some(PyMethod {
+            ref function,
+            ref object,
+        }) = func_ref.payload()
+        {
+            return self.invoke(function.clone(), args.insert(object.clone()));
+        }
         match func_ref.payload {
             PyObjectPayload::RustFunction { ref function } => function(self, args),
-            PyObjectPayload::BoundMethod {
-                ref function,
-                ref object,
-            } => self.invoke(function.clone(), args.insert(object.clone())),
             ref payload => {
                 // TODO: is it safe to just invoke __call__ otherwise?
                 trace!("invoke __call__ for: {:?}", payload);
