Fix #[pyclass(base=...)] notation

Author: youknowone

derive-impl/src/pyclass.rs

@@ -308,7 +308,7 @@ fn generate_class_def(
     ident: &Ident,
     name: &str,
     module_name: Option<&str>,
-    base: Option<String>,
+    base: Option<syn::Path>,
     metaclass: Option<String>,
     unhashable: bool,
     attrs: &[Attribute],
@@ -358,7 +358,6 @@ fn generate_class_def(
         Some(quote! { rustpython_vm::builtins::PyTuple })
     } else {
         base.as_ref().map(|typ| {
-            let typ = Ident::new(typ, ident.span());
             quote_spanned! { ident.span() => #typ }
         })
     }
@@ -382,7 +381,6 @@ fn generate_class_def(
     });
 
     let base_or_object = if let Some(base) = base {
-        let base = Ident::new(&base, ident.span());
         quote! { #base }
     } else {
         quote! { ::rustpython_vm::builtins::PyBaseObject }

derive-impl/src/util.rs

@@ -187,6 +187,35 @@ impl ItemMetaInner {
         Ok(value)
     }
 
+    pub fn _optional_path(&self, key: &str) -> Result<Option<syn::Path>> {
+        let value = if let Some((_, meta)) = self.meta_map.get(key) {
+            let Meta::NameValue(syn::MetaNameValue { value, .. }) = meta else {
+                bail_span!(
+                    meta,
+                    "#[{}({} = ...)] must be a name-value pair",
+                    self.meta_name(),
+                    key
+                )
+            };
+
+            // Try to parse as a Path (identifier or path like Foo or foo::Bar)
+            match syn::parse2::<syn::Path>(value.to_token_stream()) {
+                Ok(path) => Some(path),
+                Err(_) => {
+                    bail_span!(
+                        value,
+                        "#[{}({} = ...)] must be a valid type path (e.g., PyBaseException)",
+                        self.meta_name(),
+                        key
+                    )
+                }
+            }
+        } else {
+            None
+        };
+        Ok(value)
+    }
+
     pub fn _has_key(&self, key: &str) -> Result<bool> {
         Ok(matches!(self.meta_map.get(key), Some((_, _))))
     }
@@ -384,8 +413,8 @@ impl ClassItemMeta {
         self.inner()._optional_str("ctx")
     }
 
-    pub fn base(&self) -> Result<Option<String>> {
-        self.inner()._optional_str("base")
+    pub fn base(&self) -> Result<Option<syn::Path>> {
+        self.inner()._optional_path("base")
     }
 
     pub fn unhashable(&self) -> Result<bool> {

derive/src/lib.rs

@@ -34,7 +34,7 @@ pub fn derive_from_args(input: TokenStream) -> TokenStream {
 ///     - `IMMUTABLETYPE`: class attributes are immutable.
 /// - `with`: which trait implementations are to be included in the python class.
 /// ```rust, ignore
-/// #[pyclass(module = "my_module", name = "MyClass", base = "BaseClass")]
+/// #[pyclass(module = "my_module", name = "MyClass", base = BaseClass)]
 /// struct MyStruct {
 ///    x: i32,
 /// }

vm/src/builtins/bool.rs

@@ -77,7 +77,7 @@ impl PyObjectRef {
     }
 }
 
-#[pyclass(name = "bool", module = false, base = "PyInt")]
+#[pyclass(name = "bool", module = false, base = PyInt)]
 pub struct PyBool;
 
 impl PyPayload for PyBool {

vm/src/builtins/builtin_func.rs

@@ -148,7 +148,7 @@ impl Representable for PyNativeFunction {
 impl Unconstructible for PyNativeFunction {}
 
 // `PyCMethodObject` in CPython
-#[pyclass(name = "builtin_method", module = false, base = "PyNativeFunction")]
+#[pyclass(name = "builtin_method", module = false, base = PyNativeFunction)]
 pub struct PyNativeMethod {
     pub(crate) func: PyNativeFunction,
     pub(crate) class: &'static Py<PyType>, // TODO: the actual life is &'self