GNU Linux-libre 6.8.7-gnu
[releases.git] / rust / macros / pin_data.rs
1 // SPDX-License-Identifier: Apache-2.0 OR MIT
2
3 use crate::helpers::{parse_generics, Generics};
4 use proc_macro::{Group, Punct, Spacing, TokenStream, TokenTree};
5
6 pub(crate) fn pin_data(args: TokenStream, input: TokenStream) -> TokenStream {
7     // This proc-macro only does some pre-parsing and then delegates the actual parsing to
8     // `kernel::__pin_data!`.
9
10     let (
11         Generics {
12             impl_generics,
13             ty_generics,
14         },
15         rest,
16     ) = parse_generics(input);
17     // The struct definition might contain the `Self` type. Since `__pin_data!` will define a new
18     // type with the same generics and bounds, this poses a problem, since `Self` will refer to the
19     // new type as opposed to this struct definition. Therefore we have to replace `Self` with the
20     // concrete name.
21
22     // Errors that occur when replacing `Self` with `struct_name`.
23     let mut errs = TokenStream::new();
24     // The name of the struct with ty_generics.
25     let struct_name = rest
26         .iter()
27         .skip_while(|tt| !matches!(tt, TokenTree::Ident(i) if i.to_string() == "struct"))
28         .nth(1)
29         .and_then(|tt| match tt {
30             TokenTree::Ident(_) => {
31                 let tt = tt.clone();
32                 let mut res = vec![tt];
33                 if !ty_generics.is_empty() {
34                     // We add this, so it is maximally compatible with e.g. `Self::CONST` which
35                     // will be replaced by `StructName::<$generics>::CONST`.
36                     res.push(TokenTree::Punct(Punct::new(':', Spacing::Joint)));
37                     res.push(TokenTree::Punct(Punct::new(':', Spacing::Alone)));
38                     res.push(TokenTree::Punct(Punct::new('<', Spacing::Alone)));
39                     res.extend(ty_generics.iter().cloned());
40                     res.push(TokenTree::Punct(Punct::new('>', Spacing::Alone)));
41                 }
42                 Some(res)
43             }
44             _ => None,
45         })
46         .unwrap_or_else(|| {
47             // If we did not find the name of the struct then we will use `Self` as the replacement
48             // and add a compile error to ensure it does not compile.
49             errs.extend(
50                 "::core::compile_error!(\"Could not locate type name.\");"
51                     .parse::<TokenStream>()
52                     .unwrap(),
53             );
54             "Self".parse::<TokenStream>().unwrap().into_iter().collect()
55         });
56     let impl_generics = impl_generics
57         .into_iter()
58         .flat_map(|tt| replace_self_and_deny_type_defs(&struct_name, tt, &mut errs))
59         .collect::<Vec<_>>();
60     let mut rest = rest
61         .into_iter()
62         .flat_map(|tt| {
63             // We ignore top level `struct` tokens, since they would emit a compile error.
64             if matches!(&tt, TokenTree::Ident(i) if i.to_string() == "struct") {
65                 vec![tt]
66             } else {
67                 replace_self_and_deny_type_defs(&struct_name, tt, &mut errs)
68             }
69         })
70         .collect::<Vec<_>>();
71     // This should be the body of the struct `{...}`.
72     let last = rest.pop();
73     let mut quoted = quote!(::kernel::__pin_data! {
74         parse_input:
75         @args(#args),
76         @sig(#(#rest)*),
77         @impl_generics(#(#impl_generics)*),
78         @ty_generics(#(#ty_generics)*),
79         @body(#last),
80     });
81     quoted.extend(errs);
82     quoted
83 }
84
85 /// Replaces `Self` with `struct_name` and errors on `enum`, `trait`, `struct` `union` and `impl`
86 /// keywords.
87 ///
88 /// The error is appended to `errs` to allow normal parsing to continue.
89 fn replace_self_and_deny_type_defs(
90     struct_name: &Vec<TokenTree>,
91     tt: TokenTree,
92     errs: &mut TokenStream,
93 ) -> Vec<TokenTree> {
94     match tt {
95         TokenTree::Ident(ref i)
96             if i.to_string() == "enum"
97                 || i.to_string() == "trait"
98                 || i.to_string() == "struct"
99                 || i.to_string() == "union"
100                 || i.to_string() == "impl" =>
101         {
102             errs.extend(
103                 format!(
104                     "::core::compile_error!(\"Cannot use `{i}` inside of struct definition with \
105                         `#[pin_data]`.\");"
106                 )
107                 .parse::<TokenStream>()
108                 .unwrap()
109                 .into_iter()
110                 .map(|mut tok| {
111                     tok.set_span(tt.span());
112                     tok
113                 }),
114             );
115             vec![tt]
116         }
117         TokenTree::Ident(i) if i.to_string() == "Self" => struct_name.clone(),
118         TokenTree::Literal(_) | TokenTree::Punct(_) | TokenTree::Ident(_) => vec![tt],
119         TokenTree::Group(g) => vec![TokenTree::Group(Group::new(
120             g.delimiter(),
121             g.stream()
122                 .into_iter()
123                 .flat_map(|tt| replace_self_and_deny_type_defs(struct_name, tt, errs))
124                 .collect(),
125         ))],
126     }
127 }