Add rustpython_vm::__exports module and fix warning

Author: coolreader18

derive/src/compile_bytecode.rs

@@ -163,7 +163,7 @@ pub fn impl_py_compile_bytecode(input: TokenStream2) -> Result<TokenStream2, Dia
 
     let output = quote! {
         ({
-            use ::bincode;
+            use ::rustpython_vm::__exports::bincode;
             bincode::deserialize::<::rustpython_vm::bytecode::CodeObject>(#bytes)
                 .expect("Deserializing CodeObject failed")
         })

derive/src/pyclass.rs

@@ -11,6 +11,10 @@ enum ClassItem {
         item_ident: Ident,
         py_name: String,
     },
+    ClassMethod {
+        item_ident: Ident,
+        py_name: String,
+    },
     Property {
         item_ident: Ident,
         py_name: String,
@@ -49,8 +53,8 @@ impl ClassItem {
                 let nesteds = meta_to_vec(meta).map_err(|meta| {
                     err_span!(
                         meta,
-                        "#[pyproperty = \"...\"] cannot be a name/value, you probably meant \
-                         #[pyproperty(name = \"...\")]",
+                        "#[pymethod = \"...\"] cannot be a name/value, you probably meant \
+                         #[pymethod(name = \"...\")]",
                     )
                 })?;
                 let mut py_name = None;
@@ -80,6 +84,47 @@ 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!(
@@ -210,18 +255,20 @@ pub fn impl_pyimpl(_attr: AttributeArgs, item: Item) -> Result<TokenStream2, Dia
             _ => {}
         }
     }
-    let methods = items.iter().filter_map(|item| {
-        if let ClassItem::Method {
+    let methods = items.iter().filter_map(|item| match item {
+        ClassItem::Method {
             item_ident,
             py_name,
-        } = item
-        {
-            Some(quote! {
-                class.set_str_attr(#py_name, ctx.new_rustfunc(Self::#item_ident));
-            })
-        } else {
-            None
-        }
+        } => 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,
     });
     let properties = properties
         .iter()

vm/src/lib.rs

@@ -66,3 +66,8 @@ mod vm;
 pub use self::exceptions::print_exception;
 pub use self::vm::VirtualMachine;
 pub use rustpython_compiler::*;
+
+#[doc(hidden)]
+pub mod __exports {
+    pub use bincode;
+}

vm/src/stdlib/mod.rs

@@ -34,6 +34,7 @@ use crate::pyobject::PyObjectRef;
 pub type StdlibInitFunc = Box<dyn Fn(&VirtualMachine) -> PyObjectRef>;
 
 pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
+    #[allow(unused_mut)]
     let mut modules = hashmap! {
         "ast".to_string() => Box::new(ast::make_module) as StdlibInitFunc,
         "binascii".to_string() => Box::new(binascii::make_module),