Make more dyn Fn()s threading-optional

coolreader18 · coolreader18 · commit 7218d1d99812 · 2020-08-22T16:18:26.000-05:00
diff --git a/vm/src/function.rs b/vm/src/function.rs
@@ -9,7 +9,8 @@ use crate::exceptions::PyBaseExceptionRef;
 use crate::obj::objtuple::PyTupleRef;
 use crate::obj::objtype::{isinstance, PyClassRef};
 use crate::pyobject::{
-    BorrowValue, IntoPyResult, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
+    BorrowValue, IntoPyResult, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue,
+    TryFromObject, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -476,15 +477,8 @@ tuple_from_py_func_args!(A, B, C, D);
 tuple_from_py_func_args!(A, B, C, D, E);
 tuple_from_py_func_args!(A, B, C, D, E, F);
 
-// can't use PyThreadingConstraint for this since it's not an auto trait, and therefore we can't
-// add it ad-hoc to a trait object
-#[cfg(not(feature = "threading"))]
-pub type NativeFuncObj = dyn Fn(&VirtualMachine, PyFuncArgs) -> PyResult + 'static;
-#[cfg(feature = "threading")]
-pub type NativeFuncObj = dyn Fn(&VirtualMachine, PyFuncArgs) -> PyResult + Send + Sync + 'static;
-
 /// A built-in Python function.
-pub type PyNativeFunc = Box<NativeFuncObj>;
+pub type PyNativeFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine, PyFuncArgs) -> PyResult)>;
 
 /// Implemented by types that are or can generate built-in functions.
 ///
@@ -500,7 +494,7 @@ pub type PyNativeFunc = Box<NativeFuncObj>;
 ///
 /// A bare `PyNativeFunc` also implements this trait, allowing the above to be
 /// done manually, for rare situations that don't fit into this model.
-pub trait IntoPyNativeFunc<T, R, VM>: Sized + Send + Sync + 'static {
+pub trait IntoPyNativeFunc<T, R, VM>: Sized + PyThreadingConstraint + 'static {
     fn call(&self, vm: &VirtualMachine, args: PyFuncArgs) -> PyResult;
     fn into_func(self) -> PyNativeFunc {
         Box::new(move |vm: &VirtualMachine, args| self.call(vm, args))
@@ -509,7 +503,7 @@ pub trait IntoPyNativeFunc<T, R, VM>: Sized + Send + Sync + 'static {
 
 impl<F> IntoPyNativeFunc<PyFuncArgs, PyResult, VirtualMachine> for F
 where
-    F: Fn(&VirtualMachine, PyFuncArgs) -> PyResult + 'static + Send + Sync,
+    F: Fn(&VirtualMachine, PyFuncArgs) -> PyResult + PyThreadingConstraint + 'static,
 {
     fn call(&self, vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         (self)(vm, args)
@@ -527,7 +521,7 @@ macro_rules! into_py_native_func_tuple {
     ($(($n:tt, $T:ident)),*) => {
         impl<F, $($T,)* R> IntoPyNativeFunc<($(OwnedParam<$T>,)*), R, VirtualMachine> for F
         where
-            F: Fn($($T,)* &VirtualMachine) -> R + 'static + Send + Sync,
+            F: Fn($($T,)* &VirtualMachine) -> R + PyThreadingConstraint + 'static,
             $($T: FromArgs,)*
             R: IntoPyResult,
         {
@@ -540,7 +534,7 @@ macro_rules! into_py_native_func_tuple {
 
         impl<F, S, $($T,)* R> IntoPyNativeFunc<(RefParam<S>, $(OwnedParam<$T>,)*), R, VirtualMachine> for F
         where
-            F: Fn(&S, $($T,)* &VirtualMachine) -> R + 'static  + Send + Sync,
+            F: Fn(&S, $($T,)* &VirtualMachine) -> R + PyThreadingConstraint + 'static,
             S: PyValue,
             $($T: FromArgs,)*
             R: IntoPyResult,
@@ -554,7 +548,7 @@ macro_rules! into_py_native_func_tuple {
 
         impl<F, $($T,)* R> IntoPyNativeFunc<($(OwnedParam<$T>,)*), R, ()> for F
         where
-            F: Fn($($T,)*) -> R + 'static  + Send + Sync,
+            F: Fn($($T,)*) -> R + PyThreadingConstraint + 'static,
             $($T: FromArgs,)*
             R: IntoPyResult,
         {
@@ -567,7 +561,7 @@ macro_rules! into_py_native_func_tuple {
 
         impl<F, S, $($T,)* R> IntoPyNativeFunc<(RefParam<S>, $(OwnedParam<$T>,)*), R, ()> for F
         where
-            F: Fn(&S, $($T,)*) -> R + 'static  + Send + Sync,
+            F: Fn(&S, $($T,)*) -> R + PyThreadingConstraint + 'static,
             S: PyValue,
             $($T: FromArgs,)*
             R: IntoPyResult,
@@ -645,18 +639,16 @@ where
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     #[test]
     fn test_intonativefunc_noalloc() {
-        macro_rules! check_size {
-            ($f:expr) => {
-                let f = super::IntoPyNativeFunc::into_func(py_func);
-                assert_eq!(std::mem::size_of_val(f.as_ref()), 0);
-            };
-        }
+        let check_zst = |f: PyNativeFunc| assert_eq!(std::mem::size_of_val(f.as_ref()), 0);
         fn py_func(_b: bool, _vm: &crate::VirtualMachine) -> i32 {
             1
         }
-        check_size!(py_func);
-        check_size!(|| "foo".to_owned());
+        check_zst(py_func.into_func());
+        let empty_closure = || "foo".to_owned();
+        check_zst(empty_closure.into_func());
     }
 }
diff --git a/vm/src/macros.rs b/vm/src/macros.rs
@@ -240,3 +240,21 @@ macro_rules! named_function {
         }
     }};
 }
+
+// can't use PyThreadingConstraint for stuff like this since it's not an auto trait, and
+// therefore we can't add it ad-hoc to a trait object
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        macro_rules! py_dyn_fn {
+            (dyn Fn($($arg:ty),*$(,)*) -> $ret:ty) => {
+                dyn Fn($($arg),*) -> $ret + Send + Sync + 'static
+            };
+        }
+    } else {
+        macro_rules! py_dyn_fn {
+            (dyn Fn($($arg:ty),*$(,)*) -> $ret:ty) => {
+                dyn Fn($($arg),*) -> $ret + 'static
+            };
+        }
+    }
+}
diff --git a/vm/src/obj/objgetset.rs b/vm/src/obj/objgetset.rs
@@ -10,9 +10,9 @@ use crate::pyobject::{
 use crate::slots::SlotDescriptor;
 use crate::vm::VirtualMachine;
 
-pub type PyGetterFunc = Box<dyn Fn(&VirtualMachine, PyObjectRef) -> PyResult + Send + Sync>;
+pub type PyGetterFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine, PyObjectRef) -> PyResult)>;
 pub type PySetterFunc =
-    Box<dyn Fn(&VirtualMachine, PyObjectRef, PyObjectRef) -> PyResult<()> + Send + Sync>;
+    Box<py_dyn_fn!(dyn Fn(&VirtualMachine, PyObjectRef, PyObjectRef) -> PyResult<()>)>;
 
 pub trait IntoPyGetterFunc<T> {
     fn into_getter(self) -> PyGetterFunc;
diff --git a/vm/src/stdlib/mod.rs b/vm/src/stdlib/mod.rs
@@ -68,7 +68,7 @@ mod winreg;
 #[cfg(not(any(target_arch = "wasm32", target_os = "redox")))]
 mod zlib;
 
-pub type StdlibInitFunc = Box<dyn Fn(&VirtualMachine) -> PyObjectRef + Send + Sync>;
+pub type StdlibInitFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine) -> PyObjectRef)>;
 
 pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
     #[allow(unused_mut)]
diff --git a/wasm/lib/src/convert.rs b/wasm/lib/src/convert.rs
@@ -17,31 +17,6 @@ use rustpython_vm::{exceptions, py_serde};
 use crate::browser_module;
 use crate::vm_class::{stored_vm_from_wasm, WASMVirtualMachine};
 
-// Currently WASM do not support multithreading. We should change this once it is enabled.
-thread_local!(static JS_HANDLES: RefCell<Arena<JsValue>> = RefCell::new(Arena::new()));
-
-pub struct JsHandle(generational_arena::Index);
-impl JsHandle {
-    pub fn new(js: JsValue) -> Self {
-        let idx = JS_HANDLES.with(|arena| arena.borrow_mut().insert(js));
-        JsHandle(idx)
-    }
-    pub fn get(&self) -> JsValue {
-        JS_HANDLES.with(|arena| {
-            arena
-                .borrow()
-                .get(self.0)
-                .expect("index was removed")
-                .clone()
-        })
-    }
-}
-impl Drop for JsHandle {
-    fn drop(&mut self) {
-        JS_HANDLES.with(|arena| arena.borrow_mut().remove(self.0));
-    }
-}
-
 #[wasm_bindgen(inline_js = r"
 export class PyError extends Error {
     constructor(info) {
@@ -223,7 +198,7 @@ pub fn js_to_py(vm: &VirtualMachine, js_val: JsValue) -> PyObjectRef {
             dict.into_object()
         }
     } else if js_val.is_function() {
-        let js_handle = JsHandle::new(js_val);
+        let func = js_sys::Function::from(js_val);
         vm.ctx
             .new_method(move |vm: &VirtualMachine, args: PyFuncArgs| -> PyResult {
                 let this = Object::new();
@@ -235,7 +210,6 @@ pub fn js_to_py(vm: &VirtualMachine, js_val: JsValue) -> PyObjectRef {
                 for v in args.args {
                     js_args.push(&py_to_js(vm, v));
                 }
-                let func = js_sys::Function::from(js_handle.get());
                 func.apply(&this, &js_args)
                     .map(|val| js_to_py(vm, val))
                     .map_err(|err| js_err_to_py_err(vm, &err))
diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs
@@ -12,7 +12,7 @@ use rustpython_vm::scope::{NameProtocol, Scope};
 use rustpython_vm::{InitParameter, PySettings, VirtualMachine};
 
 use crate::browser_module::setup_browser_module;
-use crate::convert::{self, JsHandle, PyResultExt};
+use crate::convert::{self, PyResultExt};
 use crate::js_module;
 use crate::wasm_builtins;
 use rustpython_compiler::mode::Mode;
@@ -227,9 +227,8 @@ impl WASMVirtualMachine {
                     _ => return Err(error()),
                 }
             } else if stdout.is_function() {
-                let func_handle = JsHandle::new(stdout);
+                let func = js_sys::Function::from(stdout);
                 make_stdout_object(vm, move |data, vm| {
-                    let func = js_sys::Function::from(func_handle.get());
                     func.call1(&JsValue::UNDEFINED, &data.into())
                         .map_err(|err| convert::js_py_typeerror(vm, err))?;
                     Ok(())
diff --git a/wasm/lib/src/wasm_builtins.rs b/wasm/lib/src/wasm_builtins.rs
@@ -21,7 +21,7 @@ pub fn sys_stdout_write_console(data: &str, _vm: &VirtualMachine) -> PyResult<()
 
 pub fn make_stdout_object(
     vm: &VirtualMachine,
-    write_f: impl Fn(&str, &VirtualMachine) -> PyResult<()> + Send + Sync + 'static,
+    write_f: impl Fn(&str, &VirtualMachine) -> PyResult<()> + 'static,
 ) -> PyObjectRef {
     let ctx = &vm.ctx;
     let write_method = ctx.new_method(
