我目前正在尝试为自定义特征编写派生宏。 这就是我到目前为止所得到的：
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::spanned::Spanned;
use syn::{
parse_macro_input, parse_quote, Data, DeriveInput, Fields, GenericParam, Generics, Index,
};
#[proc_macro_derive(HeapSize)]
pub fn derive_heap_size(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
// Parse the input tokens into a syntax tree.
let input = parse_macro_input!(input as DeriveInput);
// Used in the quasi-quotation below as `#name`.
let name = input.ident;
// Add a bound `T: HeapSize` to every type parameter T.
let generics = add_trait_bounds(input.generics);
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
// Generate an expression to sum up the heap size of each field.
let sum = heap_size_sum(&input.data);
let expanded = quote! {
// The generated impl.
impl #impl_generics lestream::FromLeBytes for #name #ty_generics #where_clause {
fn heap_size_of_children(&self) -> usize {
#sum
}
}
};
// Hand the output tokens back to the compiler.
proc_macro::TokenStream::from(expanded)
}
// Add a bound `T: HeapSize` to every type parameter T.
fn add_trait_bounds(mut generics: Generics) -> Generics {
for param in &mut generics.params {
if let GenericParam::Type(ref mut type_param) = *param {
type_param.bounds.push(parse_quote!(lestream::FromLeBytes));
}
}
generics
}
// Generate an expression to sum up the heap size of each field.
fn heap_size_sum(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
// Expands to an expression like
//
// 0 + self.x.heap_size() + self.y.heap_size() + self.z.heap_size()
//
// but using fully qualified function call syntax.
//
// We take some care to use the span of each `syn::Field` as
// the span of the corresponding `heap_size_of_children`
// call. This way if one of the field types does not
// implement `HeapSize` then the compiler's error message
// underlines which field it is. An example is shown in the
// readme of the parent directory.
let q = quote! {
Self {
};
for field in fields.named {
let item_name = field.ident.expect("macro only works with named fields");
let item_type = field.ty;
quote! {
let #item_name = #item_type::from_le_bytes()
}
}
}
_ => panic!("The FromLeBytes derive can only be applied to structs"),
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
这个想法是通过按顺序调用结构体每个成员的特征方法
from_le_bytes()use std::fmt::{Display, Formatter};
#[derive(Debug)]
pub enum Error {
UnexpectedEndOfStream,
}
impl Display for Error {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::UnexpectedEndOfStream => write!(f, "unexpected end of stream"),
}
}
}
impl std::error::Error for Error {}
pub trait FromLeBytes: Sized {
fn from_le_bytes<T>(bytes: &mut T) -> Result<Self, Error>
where
T: Iterator<Item = u8>;
}
即：
#[derive(FromLeBytes)]
struct Foo {
bar: u8;
spamm: u16;
}
应该会产生类似
的实现impl FromLeBytes for Foo {
fn from_le_bytes<T>(bytes: &mut T) -> Result<Self, Error>
where
T: Iterator<Item = u8>;
{
Ok(Self { bar: u8::from_le_bytes(bytes)?, spamm: u16::from_le_bytes(bytes)? })
}
但是，我无法弄清楚如何在
quote!quote!我通过使用成对的大括号并使用
#identuse proc_macro2::TokenStream;
use quote::quote;
use syn::{parse_macro_input, parse_quote, Data, DeriveInput, Fields, GenericParam, Generics};
#[proc_macro_derive(FromLeBytes)]
pub fn derive_heap_size(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
// Parse the input tokens into a syntax tree.
let input = parse_macro_input!(input as DeriveInput);
// Used in the quasi-quotation below as `#name`.
let name = input.ident;
// Add a bound `T: HeapSize` to every type parameter T.
let generics = add_trait_bounds(input.generics);
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
// Generate an expression to sum up the heap size of each field.
let body = impl_body(&input.data);
let expanded = quote! {
// The generated impl.
impl #impl_generics lestream::FromLeBytes for #name #ty_generics #where_clause {
fn from_le_bytes<T>(bytes: &mut T) -> lestream::Result<Self>
where
T: Iterator<Item = u8>
{
#body
}
}
};
// Hand the output tokens back to the compiler.
proc_macro::TokenStream::from(expanded)
}
// Add a bound `T: HeapSize` to every type parameter T.
fn add_trait_bounds(mut generics: Generics) -> Generics {
for param in &mut generics.params {
if let GenericParam::Type(ref mut type_param) = *param {
type_param.bounds.push(parse_quote!(lestream::FromLeBytes));
}
}
generics
}
// Generate an expression to sum up the heap size of each field.
fn impl_body(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref strct) => {
match strct.fields {
Fields::Named(ref fields) => {
// Expands to an expression like
//
// 0 + self.x.heap_size() + self.y.heap_size() + self.z.heap_size()
//
// but using fully qualified function call syntax.
//
// We take some care to use the span of each `syn::Field` as
// the span of the corresponding `heap_size_of_children`
// call. This way if one of the field types does not
// implement `HeapSize` then the compiler's error message
// underlines which field it is. An example is shown in the
// readme of the parent directory.
let mut tokens = TokenStream::new();
let mut constructor_fields = TokenStream::new();
for field in &fields.named {
let item_name = field.ident.clone().unwrap();
let item_type = &field.ty;
tokens.extend(quote! {
let #item_name = <#item_type as lestream::FromLeBytes>::from_le_bytes(bytes)?;
});
constructor_fields.extend(quote! {
#item_name,
});
}
tokens.extend(quote! { Ok(Self { #constructor_fields }) });
tokens
}
_ => panic!("The FromLeBytes derive can only be applied to structs"),
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
自我回答中已经描述了一种方法，但我会尝试为所讨论的问题添加更多背景知识。
出现此错误的原因是
quoteTokenTreeDelimiter因此，
TokenStreamquote!{ Self { }至于为什么一定要这样——让我们想想下面的代码：
fn foo() -> proc_macro2::TokenStream {
quote!{ { }; // (1)
// imagine here's some code generating `TokenStream`,
// so that the function would be valid if this `quote` is valid
}
fn bar() -> proc_macro2::TokenStream {
quote!{ { }; // (2)
// imagine here's the same code as above in `foo`
}
}
让我们问自己：解析器在每种情况下应该如何遍历这段代码？
请注意，这里的函数
barquoteTokenStreamquotequotebar想象一下，现在，我们希望
fooquoteTokenStreamquote但现在请注意，在解析第 (1) 行和第 (2) 行时，实际上无法区分这两种情况：
foobar此外，严格来说，很可能不可能知道哪个确切的括号必须被视为不匹配。想一想：
fn foo() {
quote::quote!{ { }; { };
}
如果 Rust 允许在宏中使用不匹配的大括号，则这段代码将是不明确的：
quotequote简而言之：允许不匹配的大括号将为编译器作者和语言用户打开太多复杂性的大门。