Merge pull request RustPython#2117 from youknowone/pymodule-attr-use

Allow `use` for `#[pyattr]`

Author: youknowone

derive/src/pymodule.rs

@@ -5,7 +5,7 @@ use crate::util::{
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{quote, quote_spanned, ToTokens};
 use std::collections::HashMap;
-use syn::{parse_quote, spanned::Spanned, AttributeArgs, Ident, Item, Meta, NestedMeta};
+use syn::{parse_quote, spanned::Spanned, AttributeArgs, Ident, Item, Meta, NestedMeta, UseTree};
 
 struct Module {
     name: String,
@@ -173,33 +173,22 @@ impl Module {
                 }
                 "pyattr" => {
                     attr_idxs.push(i);
-                    match item.typ {
-                        ItemType::Fn => {
-                            items.push((
-                                Self::extract_evaluated_attr(item.ident, into_nested()?)?,
-                                meta_span,
-                            ));
-                        }
-                        ItemType::Const => {
-                            items.push((
-                                Self::extract_const_attr(item.ident, into_nested()?)?,
-                                meta_span,
-                            ));
-                        }
-                        ItemType::Struct => {
+                    let item = match item.typ {
+                        ItemType::Fn => Self::extract_evaluated_attr(item.ident, into_nested()?)?,
+                        ItemType::Const => Self::extract_const_attr(item.ident, into_nested()?)?,
+                        ItemType::Struct | ItemType::Enum => {
                             if has_class {
                                 return Err(err_span!(
                                     meta,
                                     "#[pyattr] must be placed on top of #[pyclass] or #[pystruct_sequence]",
                                 ));
                             }
-                            items.push((
-                                Self::extract_class_attr(item.ident, into_nested()?)?,
-                                meta_span,
-                            ));
+                            Self::extract_class_attr(item.ident, into_nested()?)?
                         }
-                        _ => unreachable!(),
-                    }
+                        ItemType::Use => Self::extract_const_attr(item.ident, into_nested()?)?,
+                        ItemType::Method => unreachable!(),
+                    };
+                    items.push((item, meta_span));
                 }
                 attr_name @ "pyclass" | attr_name @ "pystruct_sequence" => {
                     assert!(item.typ == ItemType::Struct);
@@ -399,28 +388,46 @@ pub fn impl_pymodule(attr: AttributeArgs, item: Item) -> Result<TokenStream2, Di
 
     let items = content
         .iter_mut()
-        .filter_map(|item| match item {
-            Item::Fn(syn::ItemFn { attrs, sig, .. }) => Some(ItemIdent {
-                typ: ItemType::Fn,
-                attrs,
-                ident: &sig.ident,
-            }),
-            Item::Struct(syn::ItemStruct { attrs, ident, .. }) => Some(ItemIdent {
-                typ: ItemType::Struct,
-                attrs,
-                ident,
-            }),
-            Item::Enum(syn::ItemEnum { attrs, ident, .. }) => Some(ItemIdent {
-                typ: ItemType::Enum,
-                attrs,
-                ident,
-            }),
-            Item::Const(syn::ItemConst { attrs, ident, .. }) => Some(ItemIdent {
-                typ: ItemType::Const,
-                attrs,
-                ident,
-            }),
-            _ => None,
+        .filter_map(|item| {
+            let item = match item {
+                Item::Fn(syn::ItemFn { attrs, sig, .. }) => ItemIdent {
+                    typ: ItemType::Fn,
+                    attrs,
+                    ident: &sig.ident,
+                },
+                Item::Struct(syn::ItemStruct { attrs, ident, .. }) => ItemIdent {
+                    typ: ItemType::Struct,
+                    attrs,
+                    ident,
+                },
+                Item::Enum(syn::ItemEnum { attrs, ident, .. }) => ItemIdent {
+                    typ: ItemType::Enum,
+                    attrs,
+                    ident,
+                },
+                Item::Const(syn::ItemConst { attrs, ident, .. }) => ItemIdent {
+                    typ: ItemType::Const,
+                    attrs,
+                    ident,
+                },
+                Item::Use(syn::ItemUse { attrs, tree, .. }) => {
+                    let ident = match tree {
+                        UseTree::Path(path) => match &*path.tree {
+                            UseTree::Name(name) => &name.ident,
+                            UseTree::Rename(rename) => &rename.rename,
+                            _ => return None,
+                        },
+                        _ => return None,
+                    };
+                    ItemIdent {
+                        typ: ItemType::Use,
+                        attrs,
+                        ident,
+                    }
+                }
+                _ => return None,
+            };
+            Some(item)
         })
         .collect();
 

derive/src/util.rs

@@ -84,6 +84,7 @@ pub(crate) enum ItemType {
     Struct,
     Enum,
     Const,
+    Use,
 }
 
 pub(crate) struct ItemIdent<'a> {

vm/src/stdlib/zlib.rs

@@ -1,19 +1,4 @@
-use crate::pyobject::PyObjectRef;
-use crate::vm::VirtualMachine;
-
-pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
-    use libz_sys as libz;
-    let module = decl::make_module(vm);
-    let ctx = &vm.ctx;
-    extend_module!(vm, module, {
-        "Z_DEFAULT_COMPRESSION" => ctx.new_int(libz::Z_DEFAULT_COMPRESSION),
-        "Z_NO_COMPRESSION" => ctx.new_int(libz::Z_NO_COMPRESSION),
-        "Z_BEST_SPEED" => ctx.new_int(libz::Z_BEST_SPEED),
-        "Z_BEST_COMPRESSION" => ctx.new_int(libz::Z_BEST_COMPRESSION),
-        "DEFLATED" => ctx.new_int(libz::Z_DEFLATED),
-    });
-    module
-}
+pub(crate) use decl::make_module;
 
 #[pymodule(name = "zlib")]
 mod decl {
@@ -37,6 +22,17 @@ mod decl {
     use libz_sys as libz;
     use std::io::Write;
 
+    #[pyattr]
+    use libz::Z_BEST_COMPRESSION;
+    #[pyattr]
+    use libz::Z_BEST_SPEED;
+    #[pyattr]
+    use libz::Z_DEFAULT_COMPRESSION;
+    #[pyattr]
+    use libz::Z_DEFLATED;
+    #[pyattr]
+    use libz::Z_NO_COMPRESSION;
+
     // copied from zlibmodule.c (commit 530f506ac91338)
     #[pyattr]
     const MAX_WBITS: u8 = 15;