Implements a proc macro for exception introspection

Author: Tpt

Cargo.toml

@@ -61,7 +61,6 @@ uuid = { version = "1.11.0", optional = true }
 lock_api = { version = "0.4", optional = true }
 parking_lot = { version = "0.12", optional = true }
 iana-time-zone = { version = "0.1", optional = true, features = ["fallback"] }
-paste = { version = "1", optional = true }
 
 [target.'cfg(not(target_has_atomic = "64"))'.dependencies]
 portable-atomic = "1.0"
@@ -94,7 +93,7 @@ experimental-async = ["macros", "pyo3-macros/experimental-async"]
 
 # Enables pyo3::inspect module and additional type information on FromPyObject
 # and IntoPy traits
-experimental-inspect = ["pyo3-macros/experimental-inspect", "paste"]
+experimental-inspect = ["pyo3-macros/experimental-inspect"]
 
 # Enables macros: #[pyclass], #[pymodule], #[pyfunction] etc.
 macros = ["pyo3-macros"]

pyo3-macros-backend/src/introspection.rs

@@ -20,10 +20,48 @@ use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::mem::take;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use syn::{Attribute, Ident, ReturnType, Type, TypePath};
+use syn::ext::IdentExt;
+use syn::parse::{Parse, ParseStream};
+use syn::{Attribute, Ident, Path, ReturnType, Token, Type, TypePath};
 
 static GLOBAL_COUNTER_FOR_UNIQUE_NAMES: AtomicUsize = AtomicUsize::new(0);
 
+/// Entry point to implement introspection on exceptions
+pub fn implement_class_introspection(options: ClassIntrospectionOptions) -> TokenStream {
+    class_introspection_code(
+        &PyO3CratePath::Given(options.pyo3_class_path),
+        &options.name,
+        &options.name.unraw().to_string(),
+        options.base.map(|t| PythonTypeHint::from_type(t, None)),
+        false,
+    )
+}
+
+pub struct ClassIntrospectionOptions {
+    pub pyo3_class_path: Path,
+    pub name: Ident,
+    pub base: Option<Type>,
+}
+
+impl Parse for ClassIntrospectionOptions {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let pyo3_class_path = input.parse()?;
+        let _: Token![,] = input.parse()?;
+        let name = input.parse()?;
+        let base = if input.peek(Token![,]) {
+            let _: Token![,] = input.parse()?;
+            Some(input.parse()?)
+        } else {
+            None
+        };
+        Ok(Self {
+            pyo3_class_path,
+            name,
+            base,
+        })
+    }
+}
+
 pub fn module_introspection_code<'a>(
     pyo3_crate_path: &PyO3CratePath,
     name: &str,

pyo3-macros-backend/src/lib.rs

@@ -30,6 +30,8 @@ mod type_hint;
 
 pub use frompyobject::build_derive_from_pyobject;
 pub use intopyobject::build_derive_into_pyobject;
+#[cfg(feature = "experimental-inspect")]
+pub use introspection::{implement_class_introspection, ClassIntrospectionOptions};
 pub use 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};

pyo3-macros/src/lib.rs

@@ -159,32 +159,25 @@ pub fn pyfunction(attr: TokenStream, input: TokenStream) -> TokenStream {
 #[proc_macro_derive(IntoPyObject, attributes(pyo3))]
 pub fn derive_into_py_object(item: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(item as syn::DeriveInput);
-    let expanded = build_derive_into_pyobject::<false>(&ast).unwrap_or_compile_error();
-    quote!(
-        #expanded
-    )
-    .into()
+    build_derive_into_pyobject::<false>(&ast)
+        .unwrap_or_compile_error()
+        .into()
 }
 
 #[proc_macro_derive(IntoPyObjectRef, attributes(pyo3))]
 pub fn derive_into_py_object_ref(item: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(item as syn::DeriveInput);
-    let expanded =
-        pyo3_macros_backend::build_derive_into_pyobject::<true>(&ast).unwrap_or_compile_error();
-    quote!(
-        #expanded
-    )
-    .into()
+    build_derive_into_pyobject::<true>(&ast)
+        .unwrap_or_compile_error()
+        .into()
 }
 
 #[proc_macro_derive(FromPyObject, attributes(pyo3))]
 pub fn derive_from_py_object(item: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(item as syn::DeriveInput);
-    let expanded = build_derive_from_pyobject(&ast).unwrap_or_compile_error();
-    quote!(
-        #expanded
-    )
-    .into()
+    build_derive_from_pyobject(&ast)
+        .unwrap_or_compile_error()
+        .into()
 }
 
 fn pyclass_impl(
@@ -254,3 +247,11 @@ impl UnwrapOrCompileError for syn::Result<TokenStream2> {
         self.unwrap_or_else(|e| e.into_compile_error())
     }
 }
+
+#[cfg(feature = "experimental-inspect")]
+#[doc(hidden)]
+#[proc_macro]
+pub fn implement_class_introspection(args: TokenStream) -> TokenStream {
+    let options = parse_macro_input!(args as pyo3_macros_backend::ClassIntrospectionOptions);
+    pyo3_macros_backend::implement_class_introspection(options).into()
+}

src/exceptions.rs

@@ -231,7 +231,7 @@ macro_rules! create_exception_type_object {
             }
         }
 
-        $crate::create_exception_introspection_data!($module, $name, $base);
+        $crate::create_exception_introspection_data!($name, $base);
     };
 }
 
@@ -240,42 +240,15 @@ macro_rules! create_exception_type_object {
 #[doc(hidden)]
 #[macro_export]
 macro_rules! create_exception_introspection_data(
-    ($module: expr, $name: ident, $base: ty) => {};
+    ($name: ident, $base: ty) => {};
 );
 
-#[cfg(feature = "experimental-inspect")]
+#[cfg(all(feature = "experimental-inspect", feature = "macros"))]
 #[doc(hidden)]
 #[macro_export]
 macro_rules! create_exception_introspection_data(
-    ($module: expr, $name: ident, $base: ty) => {
-        const _: () = {
-            const PIECES: &[&[u8]] = &[
-                b"{\"type\":\"class\",\"id\":\"",
-                $name::_PYO3_INTROSPECTION_ID.as_bytes(),
-                b"\",\"name\":\"",
-                stringify!($name).as_bytes(),
-                b"\",\"bases\":[",
-                {
-                    const BASE_LEN: usize = $crate::inspect::serialized_len_for_introspection(&<$base as $crate::type_object::PyTypeInfo>::TYPE_HINT);
-                    const BASE_SER: [u8; BASE_LEN] = {
-                        let mut result: [u8; BASE_LEN] = [0; BASE_LEN];
-                        $crate::inspect::serialize_for_introspection(&<$base as $crate::type_object::PyTypeInfo>::TYPE_HINT, &mut result);
-                        result
-                    };
-                    &BASE_SER
-                },
-                b"]}"
-            ];
-            const PIECES_LEN: usize = $crate::impl_::concat::combined_len(PIECES);
-            $crate::impl_::introspection::paste! {
-                #[used]
-                #[no_mangle]
-                static [<PYO3_INTROSPECTION_1_ $name>]: $crate::impl_::introspection::SerializedIntrospectionFragment<PIECES_LEN> = $crate::impl_::introspection::SerializedIntrospectionFragment {
-                    length: PIECES_LEN as u32,
-                    fragment: $crate::impl_::concat::combine_to_array::<PIECES_LEN>(PIECES)
-                };
-            }
-        };
+    ($name: ident, $base: ty) => {
+        $crate::implement_class_introspection!($crate, $name, $base);
     };
 );
 

src/impl_/introspection.rs

@@ -1,6 +1,5 @@
 use crate::conversion::IntoPyObject;
 use crate::inspect::TypeHint;
-pub use paste::paste;
 
 /// Trait to guess a function Python return type
 ///

src/lib.rs

@@ -445,6 +445,9 @@ mod version;
 )]
 pub use crate::conversions::*;
 
+#[cfg(all(feature = "experimental-inspect", feature = "macros"))]
+#[doc(hidden)]
+pub use pyo3_macros::implement_class_introspection;
 #[cfg(feature = "macros")]
 pub use pyo3_macros::{
     pyfunction, pymethods, pymodule, FromPyObject, IntoPyObject, IntoPyObjectRef,