add #[pymodule] mod some_module { ... }

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The deprecated `pyproto` feature is now disabled by default. [#2322](https://github.com/PyO3/pyo3/pull/2322)
 - Deprecate `ToBorrowedObject` trait (it is only used as a wrapper for `ToPyObject`). [#2333](https://github.com/PyO3/pyo3/pull/2333)
 - `impl<T, const N: usize> IntoPy<PyObject> for [T; N]` now requires `T: IntoPy` rather than `T: ToPyObject`. [#2326](https://github.com/PyO3/pyo3/pull/2326)
+- Correct `wrap_pymodule` to match normal namespacing rules: it no longer "sees through" glob imports of `use submodule::*` when `submodule::submodule` is a `#[pymodule]`. [#2326](https://github.com/PyO3/pyo3/pull/2326)
 
 ### Fixed
 

examples/maturin-starter/src/lib.rs

@@ -3,7 +3,6 @@ use pyo3::types::PyDict;
 use pyo3::wrap_pymodule;
 
 mod submodule;
-use submodule::*;
 
 #[pyclass]
 struct ExampleClass {
@@ -23,7 +22,7 @@ impl ExampleClass {
 #[pymodule]
 fn maturin_starter(py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_class::<ExampleClass>()?;
-    m.add_wrapped(wrap_pymodule!(submodule))?;
+    m.add_wrapped(wrap_pymodule!(submodule::submodule))?;
 
     // Inserting to sys.modules allows importing submodules nicely from Python
     // e.g. from maturin_starter.submodule import SubmoduleClass

examples/setuptools-rust-starter/src/lib.rs

@@ -3,7 +3,6 @@ use pyo3::types::PyDict;
 use pyo3::wrap_pymodule;
 
 mod submodule;
-use submodule::*;
 
 #[pyclass]
 struct ExampleClass {
@@ -23,7 +22,7 @@ impl ExampleClass {
 #[pymodule]
 fn _setuptools_rust_starter(py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_class::<ExampleClass>()?;
-    m.add_wrapped(wrap_pymodule!(submodule))?;
+    m.add_wrapped(wrap_pymodule!(submodule::submodule))?;
 
     // Inserting to sys.modules allows importing submodules nicely from Python
     // e.g. from setuptools_rust_starter.submodule import SubmoduleClass

pyo3-macros-backend/src/lib.rs

@@ -26,14 +26,14 @@ mod pyimpl;
 mod pymethod;
 #[cfg(feature = "pyproto")]
 mod pyproto;
-mod wrap;
 
 pub use frompyobject::build_derive_from_pyobject;
-pub use module::{process_functions_in_module, pymodule_impl, PyModuleOptions};
+pub use module::{
+    process_functions_in_module, pymodule_function_impl, pymodule_module_impl, PyModuleOptions,
+};
 pub use pyclass::{build_py_class, build_py_enum, PyClassArgs};
 pub use pyfunction::{build_py_function, PyFunctionOptions};
 pub use pyimpl::{build_py_methods, PyClassMethodsType};
 #[cfg(feature = "pyproto")]
 pub use pyproto::build_py_proto;
 pub use utils::get_doc;
-pub use wrap::{wrap_pyfunction_impl, wrap_pymodule_impl, WrapPyFunctionArgs};

pyo3-macros-backend/src/module.rs

@@ -5,11 +5,11 @@ use crate::{
     attributes::{
         self, is_attribute_ident, take_attributes, take_pyo3_options, CrateAttribute, NameAttribute,
     },
+    get_doc,
     pyfunction::{impl_wrap_pyfunction, PyFunctionOptions},
     utils::{get_pyo3_crate, PythonDoc},
-    wrap::module_def_ident,
 };
-use proc_macro2::{Span, TokenStream};
+use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{
     ext::IdentExt,
@@ -60,39 +60,153 @@ impl PyModuleOptions {
     }
 }
 
+pub fn pymodule_module_impl(mut module: syn::ItemMod) -> Result<TokenStream> {
+    let syn::ItemMod {
+        attrs,
+        vis,
+        ident,
+        mod_token,
+        content,
+        semi: _,
+    } = &mut module;
+    let items = match content {
+        Some((_, items)) => items,
+        None => bail_spanned!(module.span() => "`#[pymodule]` can only be used on inline modules"),
+    };
+    let options = PyModuleOptions::from_attrs(attrs)?;
+    let doc = get_doc(attrs, None);
+
+    let name = options.name.unwrap_or_else(|| ident.unraw());
+    let krate = get_pyo3_crate(&options.krate);
+    let pyinit_symbol = format!("PyInit_{}", name);
+
+    let mut module_items = Vec::new();
+
+    fn extract_use_items(source: &syn::UseTree, target: &mut Vec<Ident>) -> Result<()> {
+        match source {
+            syn::UseTree::Name(name) => target.push(name.ident.clone()),
+            syn::UseTree::Path(path) => extract_use_items(&path.tree, target)?,
+            syn::UseTree::Group(group) => {
+                for tree in &group.items {
+                    extract_use_items(tree, target)?
+                }
+            }
+            syn::UseTree::Glob(glob) => bail_spanned!(glob.span() => "#[pyo3] cannot import glob statements"),
+            syn::UseTree::Rename(rename) => target.push(rename.ident.clone()),
+        }
+        Ok(())
+    }
+
+    let mut pymodule_init = None;
+
+    for item in items.iter_mut() {
+        match item {
+            syn::Item::Use(item_use) => {
+                let mut is_pyo3 = false;
+                item_use.attrs.retain(|attr| {
+                    let found = attr.path.is_ident("pyo3");
+                    is_pyo3 |= found;
+                    !found
+                });
+                if is_pyo3 {
+                    extract_use_items(&item_use.tree, &mut module_items)?;
+                }
+            }
+            syn::Item::Fn(item_fn) => {
+                let mut is_module_init = false;
+                item_fn.attrs.retain(|attr| {
+                    let found = attr.path.is_ident("pymodule_init");
+                    is_module_init |= found;
+                    !found
+                });
+                if is_module_init {
+                    ensure_spanned!(pymodule_init.is_none(), item_fn.span() => "only one pymodule_init may be specified");
+                    let ident = &item_fn.sig.ident;
+                    pymodule_init = Some(quote! { #ident(module)?; });
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(quote! {
+        #vis #mod_token #ident {
+            #(#items)*
+
+            pub static DEF: #krate::impl_::pymodule::ModuleDef = unsafe {
+                use #krate::impl_::pymodule as impl_;
+                impl_::ModuleDef::new(concat!(stringify!(#name), "\0"), #doc, impl_::ModuleInitializer(__pyo3_pymodule))
+            };
+
+            pub fn __pyo3_pymodule(_py: #krate::Python, module: &#krate::types::PyModule) -> #krate::PyResult<()> {
+                #(#module_items::DEF.add_to_module(module)?;)*
+                #pymodule_init
+                Ok(())
+            }
+
+            /// This autogenerated function is called by the python interpreter when importing
+            /// the module.
+            #[export_name = #pyinit_symbol]
+            pub unsafe extern "C" fn __pyo3_init() -> *mut #krate::ffi::PyObject {
+                DEF.module_init()
+            }
+        }
+    })
+}
+
 /// Generates the function that is called by the python interpreter to initialize the native
 /// module
-pub fn pymodule_impl(
+pub fn pymodule_function_impl(
     fnname: &Ident,
     options: PyModuleOptions,
     doc: PythonDoc,
     visibility: &Visibility,
 ) -> TokenStream {
     let name = options.name.unwrap_or_else(|| fnname.unraw());
     let krate = get_pyo3_crate(&options.krate);
-    let cb_name = Ident::new(&format!("PyInit_{}", name), Span::call_site());
-
-    let module_def_name = module_def_ident(fnname);
+    let pyinit_symbol = format!("PyInit_{}", name);
 
     quote! {
-        #[no_mangle]
-        #[allow(non_snake_case)]
-        /// This autogenerated function is called by the python interpreter when importing
-        /// the module.
-        pub unsafe extern "C" fn #cb_name() -> *mut #krate::ffi::PyObject {
-            unsafe { #module_def_name.module_init() }
+        // Create a module with the same name as the `#[pymodule]` - this way `use <the module>`
+        // will actually bring both the module and the function into scope.
+        #[doc(hidden)]
+        #visibility mod #fnname {
+            pub(crate) struct MakeDef;
+            pub static DEF: #krate::impl_::pymodule::ModuleDef = MakeDef::make_def();
+
+            /// This autogenerated function is called by the python interpreter when importing
+            /// the module.
+            #[export_name = #pyinit_symbol]
+            pub unsafe extern "C" fn init() -> *mut #krate::ffi::PyObject {
+                DEF.module_init()
+            }
         }
 
-        #[doc(hidden)]
-        #visibility static #module_def_name: #krate::impl_::pymodule::ModuleDef = unsafe {
-            #krate::impl_::pymodule::ModuleDef::new(concat!(stringify!(#name), "\0"), #doc, #krate::impl_::pymodule::ModuleInitializer(#fnname))
+        // Generate the definition inside an anonymous function in the same scope as the original function -
+        // this avoids complications around the fact that the generated module has a different scope
+        // (and `super` doesn't always refer to the outer scope, e.g. if the `#[pymodule] is
+        // inside a function body)
+        const _: () = {
+            use #krate::impl_::pymodule as impl_;
+            impl #fnname::MakeDef {
+                const fn make_def() -> impl_::ModuleDef {
+                    const INITIALIZER: impl_::ModuleInitializer = impl_::ModuleInitializer(#fnname);
+                    unsafe {
+                        impl_::ModuleDef::new(concat!(stringify!(#name), "\0"), #doc, INITIALIZER)
+                    }
+                }
+            }
         };
     }
 }
 
 /// Finds and takes care of the #[pyfn(...)] in `#[pymodule]`
-pub fn process_functions_in_module(func: &mut syn::ItemFn) -> syn::Result<()> {
+pub fn process_functions_in_module(
+    options: &PyModuleOptions,
+    func: &mut syn::ItemFn,
+) -> syn::Result<()> {
     let mut stmts: Vec<syn::Stmt> = Vec::new();
+    let krate = get_pyo3_crate(&options.krate);
 
     for mut stmt in func.block.stmts.drain(..) {
         if let syn::Stmt::Item(syn::Item::Fn(func)) = &mut stmt {
@@ -102,7 +216,7 @@ pub fn process_functions_in_module(func: &mut syn::ItemFn) -> syn::Result<()> {
                 let name = &func.sig.ident;
                 let statements: Vec<syn::Stmt> = syn::parse_quote! {
                     #wrapped_function
-                    #module_name.add_function(#name::wrap(#name::DEF, #module_name)?)?;
+                    #module_name.add_function(#krate::impl_::pyfunction::wrap_pyfunction(&#name::DEF, #module_name)?)?;
                 };
                 stmts.extend(statements);
             }

pyo3-macros-backend/src/pyfunction.rs

@@ -446,12 +446,8 @@ pub fn impl_wrap_pyfunction(
         // will actually bring both the module and the function into scope.
         #[doc(hidden)]
         #vis mod #name {
-            use #krate as _pyo3;
-            pub(crate) struct PyO3Def;
-
-            // Exported for `wrap_pyfunction!`
-            pub use _pyo3::impl_::pyfunction::wrap_pyfunction as wrap;
-            pub const DEF: _pyo3::PyMethodDef = <PyO3Def as _pyo3::impl_::pyfunction::PyFunctionDef>::DEF;
+            pub(crate) struct MakeDef;
+            pub const DEF: #krate::impl_::pyfunction::PyMethodDef = MakeDef::DEF;
         }
 
         // Generate the definition inside an anonymous function in the same scope as the original function -
@@ -460,8 +456,8 @@ pub fn impl_wrap_pyfunction(
         // inside a function body)
         const _: () = {
             use #krate as _pyo3;
-            impl _pyo3::impl_::pyfunction::PyFunctionDef for #name::PyO3Def {
-                const DEF: _pyo3::PyMethodDef = #methoddef;
+            impl #name::MakeDef {
+                const DEF: #krate::impl_::pyfunction::PyMethodDef = #methoddef;
             }
         };
     };