过程宏：让编译器替我写 impl Spanned

1
error[E0107]: missing generics for struct `Tagged`
2
 --> src/bin/ch06_naive_generic.rs:5:8
3
  |
4
5 | struct Tagged<T> {
5
  |        ^^^^^^ expected 1 generic argument
6
  |
7
note: struct defined here, with 1 generic parameter: `T`
8
 --> src/bin/ch06_naive_generic.rs:5:8
9
  |
10
5 | struct Tagged<T> {
11
  |        ^^^^^^ -
12
help: add missing generic argument
13
  |
14
5 | struct Tagged<T><T> {
15
  |              +++
16

17
For more information about this error, try `rustc --explain E0107`.
18
error: could not compile `lab-ch06-derive` (bin "ch06_naive_generic") due to 1 previous error

1
error: expected `,` following `match` arm
2
 --> src/bin/ch06_no_comma.rs:4:17
3
  |
4
4 | #[derive(Spanned)]
5
  |                 ^
6
  |
7
  = note: this error originates in the derive macro `Spanned` (in Nightly builds, run with -Z macro-backtrace for more info)
8

9
error: proc-macro derive produced unparsable tokens
10
 --> src/bin/ch06_no_comma.rs:4:10
11
  |
12
4 | #[derive(Spanned)]
13
  |          ^^^^^^^
14

15
error: could not compile `lab-ch06-derive` (bin "ch06_no_comma") due to 2 previous errors

1
fn expand_spanned(input: &DeriveInput) -> syn::Result<TokenStream2> {
2
    let name = &input.ident;
3
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
4

5
    let body = match &input.data {
6
        Data::Struct(data) => {
7
            let member = span_member(&data.fields)?;
8
            // `Span` is `Copy`, so reading the field does not move anything.
9
            quote!(self.#member)
10
        }
11
        // ... enum and union arms below
12
    };
13

14
    Ok(quote! {
15
        impl #impl_generics ::pebble_span::Spanned for #name #ty_generics #where_clause {
16
            fn span(&self) -> ::pebble_span::Span {
17
                #body
18
            }
19
        }
20
    })
21
}

1
fn span_member(fields: &Fields) -> syn::Result<syn::Ident> {
2
    match fields {
3
        Fields::Named(named) => named
4
            .named
5
            .iter()
6
            .find(|field| field.ident.as_ref().is_some_and(|id| id == "span"))
7
            .and_then(|field| field.ident.clone())
8
            .ok_or_else(|| {
9
                syn::Error::new_spanned(
10
                    fields,
11
                    "expected a field named `span` for `#[derive(Spanned)]`",
12
                )
13
            }),
14
        _ => Err(syn::Error::new_spanned(
15
            fields,
16
            "`#[derive(Spanned)]` requires named fields with a `span` field",
17
        )),
18
    }
19
}

1
        Data::Enum(data) => {
2
            let arms = data
3
                .variants
4
                .iter()
5
                .map(|variant| {
6
                    let variant_name = &variant.ident;
7
                    let member = span_member(&variant.fields)?;
8
                    Ok(quote!(Self::#variant_name { #member, .. } => * #member))
9
                })
10
                .collect::<syn::Result<Vec<_>>>()?;
11
            quote! {
12
                match self {
13
                    #(#arms),*
14
                }
15
            }
16
        }
17
        Data::Union(data) => {
18
            return Err(syn::Error::new_spanned(
19
                data.union_token,
20
                "`Spanned` cannot be derived for unions",
21
            ));
22
        }

1
//! Procedural macros for the Pebble toolchain.
2
//!
3
//! This crate must be a `proc-macro = true` crate: procedural macros run at
4
//! compile time, in the compiler's process, and speak in tokens. So far it has
5
//! one flavour:
6
//!
7
//! * [`macro@Spanned`] - a **derive** macro that writes the boring
8
//!   `impl pebble_span::Spanned` for AST nodes.
9

10
use proc_macro::TokenStream;
11
use proc_macro2::TokenStream as TokenStream2;
12
use quote::quote;
13
use syn::{Data, DeriveInput, Fields, parse_macro_input};
14

15
/// Derives [`pebble_span::Spanned`](https://docs.rs/pebble-span).
16
///
17
/// Works on structs and enums that carry a field literally named `span`:
18
///
19
/// ```ignore
20
/// #[derive(Spanned)]
21
/// struct Ident { name: String, span: Span }
22
///
23
/// #[derive(Spanned)]
24
/// enum Expr {
25
///     Int { value: i64, span: Span },
26
///     Var { name: Ident, span: Span },
27
/// }
28
/// ```
29
///
30
/// For an enum, *every* variant must have the `span` field, because the derived
31
/// `span()` matches on the variant and returns its span.
32
#[proc_macro_derive(Spanned)]
33
pub fn derive_spanned(input: TokenStream) -> TokenStream {
34
    let input = parse_macro_input!(input as DeriveInput);
35
    match expand_spanned(&input) {
36
        Ok(tokens) => tokens.into(),
37
        Err(error) => error.to_compile_error().into(),
38
    }
39
}
40

41
fn expand_spanned(input: &DeriveInput) -> syn::Result<TokenStream2> {
42
    let name = &input.ident;
43
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
44

45
    let body = match &input.data {
46
        Data::Struct(data) => {
47
            let member = span_member(&data.fields)?;
48
            // `Span` is `Copy`, so reading the field does not move anything.
49
            quote!(self.#member)
50
        }
51
        Data::Enum(data) => {
52
            let arms = data
53
                .variants
54
                .iter()
55
                .map(|variant| {
56
                    let variant_name = &variant.ident;
57
                    let member = span_member(&variant.fields)?;
58
                    Ok(quote!(Self::#variant_name { #member, .. } => * #member))
59
                })
60
                .collect::<syn::Result<Vec<_>>>()?;
61
            quote! {
62
                match self {
63
                    #(#arms),*
64
                }
65
            }
66
        }
67
        Data::Union(data) => {
68
            return Err(syn::Error::new_spanned(
69
                data.union_token,
70
                "`Spanned` cannot be derived for unions",
71
            ));
72
        }
73
    };
74

75
    Ok(quote! {
76
        impl #impl_generics ::pebble_span::Spanned for #name #ty_generics #where_clause {
77
            fn span(&self) -> ::pebble_span::Span {
78
                #body
79
            }
80
        }
81
    })
82
}
83

84
fn span_member(fields: &Fields) -> syn::Result<syn::Ident> {
85
    match fields {
86
        Fields::Named(named) => named
87
            .named
88
            .iter()
89
            .find(|field| field.ident.as_ref().is_some_and(|id| id == "span"))
90
            .and_then(|field| field.ident.clone())
91
            .ok_or_else(|| {
92
                syn::Error::new_spanned(
93
                    fields,
94
                    "expected a field named `span` for `#[derive(Spanned)]`",
95
                )
96
            }),
97
        _ => Err(syn::Error::new_spanned(
98
            fields,
99
            "`#[derive(Spanned)]` requires named fields with a `span` field",
100
        )),
101
    }
102
}

1
expansion for `Ident`:
2
impl :: pebble_span :: Spanned for Ident
3
{ fn span(& self) -> :: pebble_span :: Span { self.span } }
4

5
expansion for `Expr`:
6
impl :: pebble_span :: Spanned for Expr
7
{
8
    fn span(& self) -> :: pebble_span :: Span
9
    {
10
        match self
11
        {
12
            Self :: Int { span, .. } => * span, Self :: Var { span, .. } => *
13
            span
14
        }
15
    }
16
}

1
impl ::pebble_span::Spanned for Stmt {
2
    fn span(&self) -> ::pebble_span::Span {
3
        match self {
4
            Self::Let { span, .. } => *span,
5
            Self::Fn { span, .. } => *span,
6
            Self::Expr { span, .. } => *span,
7
            Self::If { span, .. } => *span,
8
            Self::While { span, .. } => *span,
9
            Self::For { span, .. } => *span,
10
            Self::Return { span, .. } => *span,
11
            Self::Break { span, .. } => *span,
12
            Self::Continue { span, .. } => *span,
13
        }
14
    }
15
}