Adds pyexception macro

Author: sobolevn

derive/src/lib.rs

@@ -41,6 +41,13 @@ pub fn pyclass(attr: TokenStream, item: TokenStream) -> TokenStream {
     result_to_tokens(pyclass::impl_pyclass(attr, item))
 }
 
+#[proc_macro_attribute]
+pub fn pyexception(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr as AttributeArgs);
+    let item = parse_macro_input!(item as Item);
+    result_to_tokens(pyclass::impl_pyexception(attr, item))
+}
+
 #[proc_macro_attribute]
 pub fn pyimpl(attr: TokenStream, item: TokenStream) -> TokenStream {
     let attr = parse_macro_input!(attr as AttributeArgs);

derive/src/pyclass.rs

@@ -258,6 +258,39 @@ pub(crate) fn impl_pyclass(
     Ok(ret)
 }
 
+/// Special macro to create exception types.
+///
+/// Why do we need it and why can't we just use `pyclass` macro instead?
+/// We generate exception types with a `macro_rules`,
+/// similar to how CPython does it.
+/// But, inside `macro_rules` we don't have an opportunity
+/// to add non-literal attributes to `pyclass`.
+/// That's why we have to use this proxy.
+pub(crate) fn impl_pyexception(
+    attr: AttributeArgs,
+    item: Item,
+) -> std::result::Result<TokenStream, Diagnostic> {
+    let class_name = parse_vec_ident(&attr, &item, 0, "first 'class_name'".to_owned())?;
+    let base_class_name = parse_vec_ident(&attr, &item, 1, "first 'base_class_name'".to_owned())?;
+
+    // We also need to strip `Py` prefix from `class_name`,
+    // due to implementation and Python naming conventions mismatch:
+    // `PyKeyboardInterrupt` -> `KeyboardInterrupt`
+    let class_name = class_name
+        .strip_prefix("Py")
+        .ok_or_else(|| syn::Error::new_spanned(
+            &item,
+            "We require 'class_name' to have 'Py' prefix",
+        ))?;
+
+    // We just "proxy" it into `pyclass` macro, because, exception is a class.
+    let ret = quote! {
+        #[pyclass(module = false, name = #class_name, base = #base_class_name)]
+        #item
+    };
+    Ok(ret)
+}
+
 /// #[pymethod] and #[pyclassmethod]
 struct MethodItem {
     inner: ContentItemInner,
@@ -935,3 +968,23 @@ where
     }
     Ok((result, cfgs))
 }
+
+fn parse_vec_ident(
+    attr: &[NestedMeta],
+    item: &Item,
+    index: usize,
+    message: String,
+) -> std::result::Result<String, Diagnostic> {
+    Ok(attr
+        .get(index)
+        .ok_or_else(|| syn::Error::new_spanned(
+            &item,
+            format!("We require {} argument to be set", &message),
+        ))?
+        .get_ident()
+        .ok_or_else(|| syn::Error::new_spanned(
+            &item,
+            format!("We require {} argument to be ident or string", &message),
+        ))?
+        .to_string())
+}

derive/src/pymodule.rs

@@ -109,6 +109,7 @@ fn new_module_item(
             inner: ContentItemInner { index, attr_name },
             pyattrs: pyattrs.unwrap_or_else(Vec::new),
         }),
+        "pyexception" => unreachable!("#[pyexception] {:?}", pyattrs.unwrap_or_else(Vec::new)),
         other => unreachable!("#[pymodule] doesn't accept #[{}]", other),
     }
 }

derive/src/util.rs

@@ -12,6 +12,7 @@ pub(crate) const ALL_ALLOWED_NAMES: &[&str] = &[
     "pyproperty",
     "pyfunction",
     "pyclass",
+    "pyexception",
     "pystruct_sequence",
     "pyattr",
     "pyslot",
@@ -96,7 +97,7 @@ impl ItemMetaInner {
                     Err(syn::Error::new_spanned(
                         ident,
                         format!(
-                            "#[{}({})] is not one of allowed attributes {}",
+                            "#[{}({})] is not one of allowed attributes [{}]",
                             meta_ident.to_string(),
                             name,
                             allowed_names.join(", ")

vm/src/exceptions.rs

@@ -526,16 +526,12 @@ macro_rules! extends_exception {
     // This case is like `SimpleExtendsException`:
     (
         $class_name: ident,
-        $class_name_literal: literal,
         $base_class: ident,
-        $base_class_literal: literal,
         $docs: tt
     ) => {
         extends_exception!(
             $class_name,
-            $class_name_literal,
             $base_class,
-            $base_class_literal,
             $docs,
             {}
         );
@@ -546,13 +542,11 @@ macro_rules! extends_exception {
     // This case is like `ComplexExtendsException`:
     (
         $class_name: ident,
-        $class_name_literal: literal,
         $base_class: ident,
-        $base_class_literal: literal,
         $docs: tt,
         { $($attr_name:expr => $attr_value:expr),* $(,)* }
     ) => {
-        #[pyclass(module = false, name = $class_name_literal, base = $base_class_literal)]
+        #[pyexception($class_name, $base_class)]
         #[derive(Debug)]
         struct $class_name {}
 
@@ -585,11 +579,9 @@ macro_rules! extends_exception {
 }
 
 extends_exception! {
-  PyKeyboardInterrupt,
-  "KeyboardInterrupt",
-  PyBaseException,
-  "PyBaseException",
-  "Program interrupted by user."
+    PyKeyboardInterrupt,
+    PyBaseException,
+    "Program interrupted by user."
 }
 
 impl ExceptionZoo {