Add PyCallable

Author: coolreader18

vm/src/pyobject.rs

@@ -878,6 +878,39 @@ where
     }
 }
 
+#[derive(Clone)]
+pub struct PyCallable {
+    obj: PyObjectRef,
+}
+
+impl PyCallable {
+    #[inline]
+    pub fn invoke(&self, args: impl Into<PyFuncArgs>, vm: &VirtualMachine) -> PyResult {
+        vm.invoke(self.obj.clone(), args)
+    }
+
+    #[inline]
+    pub fn into_object(self) -> PyObjectRef {
+        self.obj
+    }
+}
+
+impl TryFromObject for PyCallable {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        if vm.is_callable(&obj) {
+            Ok(PyCallable { obj })
+        } else {
+            Err(vm.new_type_error(format!("'{}' object is not callable", obj.class().name)))
+        }
+    }
+}
+
+impl IntoPyObject for PyCallable {
+    fn into_pyobject(self, _vm: &VirtualMachine) -> PyResult {
+        Ok(self.into_object())
+    }
+}
+
 pub trait IdProtocol {
     fn get_id(&self) -> usize;
     fn is<T>(&self, other: &T) -> bool

vm/src/vm.rs

@@ -341,11 +341,7 @@ impl VirtualMachine {
         }
     }
 
-    pub fn invoke<T>(&self, func_ref: PyObjectRef, args: T) -> PyResult
-    where
-        T: Into<PyFuncArgs>,
-    {
-        let args = args.into();
+    fn _invoke(&self, func_ref: PyObjectRef, args: PyFuncArgs) -> PyResult {
         trace!("Invoke: {:?} {:?}", func_ref, args);
         if let Some(PyFunction {
             ref code,
@@ -354,22 +350,29 @@ impl VirtualMachine {
             ref kw_only_defaults,
         }) = func_ref.payload()
         {
-            return self.invoke_python_function(code, scope, defaults, kw_only_defaults, args);
-        }
-        if let Some(PyMethod {
+            self.invoke_python_function(code, scope, defaults, kw_only_defaults, args)
+        } else if let Some(PyMethod {
             ref function,
             ref object,
         }) = func_ref.payload()
         {
-            return self.invoke(function.clone(), args.insert(object.clone()));
-        }
-        if let Some(PyBuiltinFunction { ref value }) = func_ref.payload() {
-            return value(self, args);
+            self.invoke(function.clone(), args.insert(object.clone()))
+        } else if let Some(PyBuiltinFunction { ref value }) = func_ref.payload() {
+            value(self, args)
+        } else {
+            // TODO: is it safe to just invoke __call__ otherwise?
+            trace!("invoke __call__ for: {:?}", &func_ref.payload);
+            self.call_method(&func_ref, "__call__", args)
         }
+    }
 
-        // TODO: is it safe to just invoke __call__ otherwise?
-        trace!("invoke __call__ for: {:?}", &func_ref.payload);
-        self.call_method(&func_ref, "__call__", args)
+    // TODO: make func_ref an &PyObjectRef
+    #[inline]
+    pub fn invoke<T>(&self, func_ref: PyObjectRef, args: T) -> PyResult
+    where
+        T: Into<PyFuncArgs>,
+    {
+        self._invoke(func_ref, args.into())
     }
 
     fn invoke_python_function(

wasm/lib/src/browser_module.rs

@@ -7,10 +7,11 @@ use wasm_bindgen_futures::{future_to_promise, JsFuture};
 
 use rustpython_vm::function::{OptionalArg, PyFuncArgs};
 use rustpython_vm::obj::{
-    objdict::PyDictRef, objfunction::PyFunctionRef, objint::PyIntRef, objstr::PyStringRef,
-    objtype::PyClassRef,
+    objdict::PyDictRef, objint::PyIntRef, objstr::PyStringRef, objtype::PyClassRef,
+};
+use rustpython_vm::pyobject::{
+    PyCallable, PyClassImpl, PyObject, PyObjectRef, PyRef, PyResult, PyValue,
 };
-use rustpython_vm::pyobject::{PyClassImpl, PyObject, PyObjectRef, PyRef, PyResult, PyValue};
 use rustpython_vm::VirtualMachine;
 
 use crate::{convert, vm_class::weak_vm, wasm_builtins::window};
@@ -113,7 +114,7 @@ fn browser_fetch(url: PyStringRef, args: FetchArgs, vm: &VirtualMachine) -> PyRe
     Ok(PyPromise::from_future(future).into_ref(vm).into_object())
 }
 
-fn browser_request_animation_frame(func: PyFunctionRef, vm: &VirtualMachine) -> PyResult {
+fn browser_request_animation_frame(func: PyCallable, vm: &VirtualMachine) -> PyResult {
     use std::{cell::RefCell, rc::Rc};
 
     // this basic setup for request_animation_frame taken from:
@@ -192,8 +193,8 @@ impl PyPromise {
     #[pymethod]
     fn then(
         &self,
-        on_fulfill: PyFunctionRef,
-        on_reject: OptionalArg<PyFunctionRef>,
+        on_fulfill: PyCallable,
+        on_reject: OptionalArg<PyCallable>,
         vm: &VirtualMachine,
     ) -> PyPromiseRef {
         let weak_vm = weak_vm(vm);
@@ -224,7 +225,7 @@ impl PyPromise {
     }
 
     #[pymethod]
-    fn catch(&self, on_reject: PyFunctionRef, vm: &VirtualMachine) -> PyPromiseRef {
+    fn catch(&self, on_reject: PyCallable, vm: &VirtualMachine) -> PyPromiseRef {
         let weak_vm = weak_vm(vm);
 
         let ret_future = JsFuture::from(self.value.clone()).then(move |res| {