Move classmethods on JsValue to be normal methods

Author: coolreader18

derive/src/pyclass.rs

@@ -11,10 +11,6 @@ enum ClassItem {
         item_ident: Ident,
         py_name: String,
     },
-    ClassMethod {
-        item_ident: Ident,
-        py_name: String,
-    },
     Property {
         item_ident: Ident,
         py_name: String,
@@ -53,8 +49,8 @@ impl ClassItem {
                 let nesteds = meta_to_vec(meta).map_err(|meta| {
                     err_span!(
                         meta,
-                        "#[pymethod = \"...\"] cannot be a name/value, you probably meant \
-                         #[pymethod(name = \"...\")]",
+                        "#[pyproperty = \"...\"] cannot be a name/value, you probably meant \
+                         #[pyproperty(name = \"...\")]",
                     )
                 })?;
                 let mut py_name = None;
@@ -84,47 +80,6 @@ impl ClassItem {
                     py_name: py_name.unwrap_or_else(|| sig.ident.to_string()),
                 });
                 attr_idx = Some(i);
-            } else if name == "pyclassmethod" {
-                if item.is_some() {
-                    bail_span!(
-                        sig.ident,
-                        "You can only have one #[py*] attribute on an impl item"
-                    )
-                }
-                let nesteds = meta_to_vec(meta).map_err(|meta| {
-                    err_span!(
-                        meta,
-                        "#[pyclassmethod = \"...\"] cannot be a name/value, you probably meant \
-                         #[pyclassmethod(name = \"...\")]",
-                    )
-                })?;
-                let mut py_name = None;
-                for meta in nesteds {
-                    let meta = match meta {
-                        NestedMeta::Meta(meta) => meta,
-                        NestedMeta::Literal(_) => continue,
-                    };
-                    match meta {
-                        Meta::NameValue(name_value) => {
-                            if name_value.ident == "name" {
-                                if let Lit::Str(s) = &name_value.lit {
-                                    py_name = Some(s.value());
-                                } else {
-                                    bail_span!(
-                                        &sig.ident,
-                                        "#[pyclassmethod(name = ...)] must be a string"
-                                    );
-                                }
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                item = Some(ClassItem::ClassMethod {
-                    item_ident: sig.ident.clone(),
-                    py_name: py_name.unwrap_or_else(|| sig.ident.to_string()),
-                });
-                attr_idx = Some(i);
             } else if name == "pyproperty" {
                 if item.is_some() {
                     bail_span!(
@@ -255,20 +210,18 @@ pub fn impl_pyimpl(_attr: AttributeArgs, item: Item) -> Result<TokenStream2, Dia
             _ => {}
         }
     }
-    let methods = items.iter().filter_map(|item| match item {
-        ClassItem::Method {
+    let methods = items.iter().filter_map(|item| {
+        if let ClassItem::Method {
             item_ident,
             py_name,
-        } => Some(quote! {
-            class.set_str_attr(#py_name, ctx.new_rustfunc(Self::#item_ident));
-        }),
-        ClassItem::ClassMethod {
-            item_ident,
-            py_name,
-        } => Some(quote! {
-            class.set_str_attr(#py_name, ctx.new_classmethod(Self::#item_ident));
-        }),
-        _ => None,
+        } = item
+        {
+            Some(quote! {
+                class.set_str_attr(#py_name, ctx.new_rustfunc(Self::#item_ident));
+            })
+        } else {
+            None
+        }
     });
     let properties = properties
         .iter()

wasm/lib/src/browser.py

@@ -4,13 +4,16 @@
 from _window import window
 
 
+jsstr = window.new_from_str
+
+
 _alert = window.get_prop("alert")
 
 
 def alert(msg):
     if type(msg) != str:
         raise TypeError("msg must be a string")
-    _alert.call(JsValue.fromstr(msg))
+    _alert.call(jsstr(msg))
 
 
 _confirm = window.get_prop("confirm")
@@ -19,7 +22,7 @@ def alert(msg):
 def confirm(msg):
     if type(msg) != str:
         raise TypeError("msg must be a string")
-    return _confirm.call(JsValue.fromstr(msg)).as_bool()
+    return _confirm.call(jsstr(msg)).as_bool()
 
 
 _prompt = window.get_prop("prompt")
@@ -31,7 +34,4 @@ def prompt(msg, default_val=None):
     if default_val is not None and type(default_val) != str:
         raise TypeError("default_val must be a string")
 
-    return _prompt.call(
-        JsValue.fromstr(arg) for arg in [msg, default_val] if arg
-    ).as_str()
-
+    return _prompt.call(*(jsstr(arg) for arg in [msg, default_val] if arg)).as_str()

wasm/lib/src/js_module.rs

@@ -70,32 +70,28 @@ impl PyJsValue {
         }
     }
 
-    #[pyclassmethod]
-    fn null(cls: PyClassRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
-        PyJsValue::new(JsValue::NULL).into_ref_with_type(vm, cls)
+    #[pymethod]
+    fn null(&self, _vm: &VirtualMachine) -> PyJsValue {
+        PyJsValue::new(JsValue::NULL)
     }
 
-    #[pyclassmethod]
-    fn undefined(cls: PyClassRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
-        PyJsValue::new(JsValue::UNDEFINED).into_ref_with_type(vm, cls)
+    #[pymethod]
+    fn undefined(&self, _vm: &VirtualMachine) -> PyJsValue {
+        PyJsValue::new(JsValue::UNDEFINED)
     }
 
-    #[pyclassmethod]
-    fn fromstr(cls: PyClassRef, s: PyStringRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
-        PyJsValue::new(s.as_str()).into_ref_with_type(vm, cls)
+    #[pymethod]
+    fn new_from_str(&self, s: PyStringRef, _vm: &VirtualMachine) -> PyJsValue {
+        PyJsValue::new(s.as_str())
     }
 
-    #[pyclassmethod]
-    fn fromfloat(cls: PyClassRef, n: PyFloatRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
-        PyJsValue::new(n.to_f64()).into_ref_with_type(vm, cls)
+    #[pymethod]
+    fn new_from_float(&self, n: PyFloatRef, _vm: &VirtualMachine) -> PyJsValue {
+        PyJsValue::new(n.to_f64())
     }
 
-    #[pyclassmethod]
-    fn new_object(
-        cls: PyClassRef,
-        opts: NewObjectOptions,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyJsValueRef> {
+    #[pymethod]
+    fn new_object(&self, opts: NewObjectOptions, vm: &VirtualMachine) -> PyResult<PyJsValue> {
         let value = if let Some(proto) = opts.prototype {
             if let Some(proto) = proto.value.dyn_ref::<Object>() {
                 Object::create(proto)
@@ -107,7 +103,7 @@ impl PyJsValue {
         } else {
             Object::new()
         };
-        PyJsValue::new(value).into_ref_with_type(vm, cls)
+        Ok(PyJsValue::new(value))
     }
 
     #[pymethod]