Split some of #[pyclass] off into #[pyimpl]

coolreader18 · coolreader18 · commit 53b46a7b3245 · 2019-03-31T17:23:33.000-05:00
diff --git a/derive/src/lib.rs b/derive/src/lib.rs
@@ -52,5 +52,12 @@ pub fn derive_from_args(input: TokenStream) -> TokenStream {
 pub fn pyclass(attr: TokenStream, item: TokenStream) -> TokenStream {
     let attr = parse_macro_input!(attr as AttributeArgs);
     let item = parse_macro_input!(item as Item);
-    pyclass::impl_py_class(attr, item).into()
+    pyclass::impl_pyclass(attr, item).into()
+}
+
+#[proc_macro_attribute]
+pub fn pyimpl(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr as AttributeArgs);
+    let item = parse_macro_input!(item as Item);
+    pyclass::impl_pyimpl(attr, item).into()
 }
diff --git a/derive/src/pyclass.rs b/derive/src/pyclass.rs
@@ -89,13 +89,62 @@ impl Method {
     }
 }
 
-pub fn impl_py_class(attr: AttributeArgs, item: Item) -> TokenStream2 {
+pub fn impl_pyimpl(attr: AttributeArgs, item: Item) -> TokenStream2 {
     let mut imp = if let Item::Impl(imp) = item {
         imp
     } else {
         return quote!(#item);
     };
+
+    let rp_path = rustpython_path_attr(&attr);
+
+    let methods = imp
+        .items
+        .iter_mut()
+        .filter_map(|item| {
+            if let ImplItem::Method(meth) = item {
+                Method::from_syn(&mut meth.attrs, &meth.sig)
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+    let ty = &imp.self_ty;
+    let methods = methods.iter().map(
+        |Method {
+             py_name,
+             fn_name,
+             kind,
+         }| {
+            let constructor_fn = kind.to_ctx_constructor_fn();
+            quote! {
+                ctx.set_attr(class, #py_name, ctx.#constructor_fn(Self::#fn_name));
+            }
+        },
+    );
+
+    quote! {
+        #imp
+        impl #rp_path::pyobject::PyClassImpl for #ty {
+            fn impl_extend_class(
+                ctx: &#rp_path::pyobject::PyContext,
+                class: &#rp_path::obj::objtype::PyClassRef,
+            ) {
+                #(#methods)*
+            }
+        }
+    }
+}
+
+pub fn impl_pyclass(attr: AttributeArgs, item: Item) -> TokenStream2 {
+    let struc = if let Item::Struct(struc) = item {
+        struc
+    } else {
+        panic!("#[pyclass] can only be on a struct declaration");
+    };
+
     let rp_path = rustpython_path_attr(&attr);
+
     let mut class_name = None;
     for attr in attr {
         if let NestedMeta::Meta(meta) = attr {
@@ -110,9 +159,10 @@ pub fn impl_py_class(attr: AttributeArgs, item: Item) -> TokenStream2 {
             }
         }
     }
-    let class_name = class_name.expect("#[pyclass] must have a name");
+    let class_name = class_name.unwrap_or_else(|| struc.ident.to_string());
+
     let mut doc: Option<Vec<String>> = None;
-    for attr in imp.attrs.iter() {
+    for attr in struc.attrs.iter() {
         if attr.path.is_ident("doc") {
             let meta = attr.parse_meta().expect("expected doc attr to be a meta");
             if let Meta::NameValue(name_value) = meta {
@@ -125,8 +175,6 @@ pub fn impl_py_class(attr: AttributeArgs, item: Item) -> TokenStream2 {
                 } else {
                     panic!("expected #[doc = ...] to be a string")
                 }
-            } else {
-                panic!("expected #[doc] to be a NameValue, e.g. #[doc = \"...\"");
             }
         }
     }
@@ -137,42 +185,14 @@ pub fn impl_py_class(attr: AttributeArgs, item: Item) -> TokenStream2 {
         }
         None => quote!(None),
     };
-    let methods = imp
-        .items
-        .iter_mut()
-        .filter_map(|item| {
-            if let ImplItem::Method(meth) = item {
-                Method::from_syn(&mut meth.attrs, &meth.sig)
-            } else {
-                None
-            }
-        })
-        .collect::<Vec<_>>();
-    let ty = &imp.self_ty;
-    let methods = methods.iter().map(
-        |Method {
-             py_name,
-             fn_name,
-             kind,
-         }| {
-            let constructor_fn = kind.to_ctx_constructor_fn();
-            quote! {
-                ctx.set_attr(class, #py_name, ctx.#constructor_fn(Self::#fn_name));
-            }
-        },
-    );
+
+    let ty = &struc.ident;
 
     quote! {
-        #imp
-        impl #rp_path::pyobject::IntoPyClass for #ty {
+        #struc
+        impl #rp_path::pyobject::PyClassDef for #ty {
             const NAME: &'static str = #class_name;
             const DOC: Option<&'static str> = #doc;
-            fn _extend_class(
-                ctx: &#rp_path::pyobject::PyContext,
-                class: &#rp_path::obj::objtype::PyClassRef,
-            ) {
-                #(#methods)*
-            }
         }
     }
 }
diff --git a/vm/src/obj/objstr.rs b/vm/src/obj/objstr.rs
@@ -10,7 +10,7 @@ use unicode_segmentation::UnicodeSegmentation;
 use crate::format::{FormatParseError, FormatPart, FormatString};
 use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
-    IdProtocol, IntoPyClass, IntoPyObject, PyContext, PyIterable, PyObjectRef, PyRef, PyResult,
+    IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef, PyResult,
     PyValue, TryFromObject, TryIntoRef, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
@@ -20,6 +20,17 @@ use super::objsequence::PySliceableSequence;
 use super::objslice::PySlice;
 use super::objtype::{self, PyClassRef};
 
+/// str(object='') -> str
+/// str(bytes_or_buffer[, encoding[, errors]]) -> str
+///
+/// Create a new string object from the given object. If encoding or
+/// errors is specified, then the object must expose a data buffer
+/// that will be decoded using the given encoding and error handler.
+/// Otherwise, returns the result of object.__str__() (if defined)
+/// or repr(object).
+/// encoding defaults to sys.getdefaultencoding().
+/// errors defaults to 'strict'."
+#[pyclass(name = "str", __inside_vm)]
 #[derive(Clone, Debug)]
 pub struct PyString {
     // TODO: shouldn't be public
@@ -48,17 +59,7 @@ impl TryIntoRef<PyString> for &str {
     }
 }
 
-#[pyclass(__inside_vm, name = "str")]
-/// str(object='') -> str
-/// str(bytes_or_buffer[, encoding[, errors]]) -> str
-///
-/// Create a new string object from the given object. If encoding or
-/// errors is specified, then the object must expose a data buffer
-/// that will be decoded using the given encoding and error handler.
-/// Otherwise, returns the result of object.__str__() (if defined)
-/// or repr(object).
-/// encoding defaults to sys.getdefaultencoding().
-/// errors defaults to 'strict'."
+#[pyimpl(__inside_vm)]
 impl PyStringRef {
     // TODO: should with following format
     // class str(object='')
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -1259,14 +1259,24 @@ where
     }
 }
 
-pub trait IntoPyClass {
+pub trait PyClassDef {
     const NAME: &'static str;
     const DOC: Option<&'static str> = None;
+}
+
+impl<T> PyClassDef for PyRef<T>
+where
+    T: PyClassDef,
+{
+    const NAME: &'static str = T::NAME;
+    const DOC: Option<&'static str> = T::DOC;
+}
 
-    fn _extend_class(ctx: &PyContext, class: &PyClassRef);
+pub trait PyClassImpl: PyClassDef {
+    fn impl_extend_class(ctx: &PyContext, class: &PyClassRef);
 
     fn extend_class(ctx: &PyContext, class: &PyClassRef) {
-        Self::_extend_class(ctx, class);
+        Self::impl_extend_class(ctx, class);
         if let Some(doc) = Self::DOC {
             ctx.set_attr(class, "__doc__", ctx.new_str(doc.into()));
         }
