2023-08-14 08:46:41 +00:00
// SPDX-License-Identifier: GPL-2.0
use crate ::helpers ::{ parse_generics , Generics } ;
use proc_macro ::{ TokenStream , TokenTree } ;
pub ( crate ) fn derive ( input : TokenStream ) -> TokenStream {
let (
Generics {
impl_generics ,
rust: macros: add `decl_generics` to `parse_generics()`
The generic parameters on a type definition can specify default values.
Currently `parse_generics()` cannot handle this though. For example when
parsing the following generics:
<T: Clone, const N: usize = 0>
The `impl_generics` will be set to `T: Clone, const N: usize = 0` and
`ty_generics` will be set to `T, N`. Now using the `impl_generics` on an
impl block:
impl<$($impl_generics)*> Foo {}
will result in invalid Rust code, because default values are only
available on type definitions.
Therefore add parsing support for generic parameter default values using
a new kind of generics called `decl_generics` and change the old
behavior of `impl_generics` to not contain the generic parameter default
values.
Now `Generics` has three fields:
- `impl_generics`: the generics with bounds
(e.g. `T: Clone, const N: usize`)
- `decl_generics`: the generics with bounds and default values
(e.g. `T: Clone, const N: usize = 0`)
- `ty_generics`: contains the generics without bounds and without
default values (e.g. `T, N`)
`impl_generics` is designed to be used on `impl<$impl_generics>`,
`decl_generics` for the type definition, so `struct Foo<$decl_generics>`
and `ty_generics` whenever you use the type, so `Foo<$ty_generics>`.
Here is an example that uses all three different types of generics:
let (Generics { decl_generics, impl_generics, ty_generics }, rest) = parse_generics(input);
quote! {
struct Foo<$($decl_generics)*> {
// ...
}
impl<$impl_generics> Foo<$ty_generics> {
fn foo() {
// ...
}
}
}
The next commit contains a fix to the `#[pin_data]` macro making it
compatible with generic parameter default values by relying on this new
behavior.
Signed-off-by: Benno Lossin <benno.lossin@proton.me>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Link: https://lore.kernel.org/r/20240309155243.482334-1-benno.lossin@proton.me
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
2024-03-09 15:53:25 +00:00
decl_generics : _ ,
2023-08-14 08:46:41 +00:00
ty_generics ,
} ,
mut rest ,
) = parse_generics ( input ) ;
// This should be the body of the struct `{...}`.
let last = rest . pop ( ) ;
// Now we insert `Zeroable` as a bound for every generic parameter in `impl_generics`.
let mut new_impl_generics = Vec ::with_capacity ( impl_generics . len ( ) ) ;
// Are we inside of a generic where we want to add `Zeroable`?
let mut in_generic = ! impl_generics . is_empty ( ) ;
// Have we already inserted `Zeroable`?
let mut inserted = false ;
// Level of `<>` nestings.
let mut nested = 0 ;
for tt in impl_generics {
match & tt {
// If we find a `,`, then we have finished a generic/constant/lifetime parameter.
TokenTree ::Punct ( p ) if nested = = 0 & & p . as_char ( ) = = ',' = > {
if in_generic & & ! inserted {
new_impl_generics . extend ( quote! { : ::kernel ::init ::Zeroable } ) ;
}
in_generic = true ;
inserted = false ;
new_impl_generics . push ( tt ) ;
}
// If we find `'`, then we are entering a lifetime.
TokenTree ::Punct ( p ) if nested = = 0 & & p . as_char ( ) = = '\'' = > {
in_generic = false ;
new_impl_generics . push ( tt ) ;
}
TokenTree ::Punct ( p ) if nested = = 0 & & p . as_char ( ) = = ':' = > {
new_impl_generics . push ( tt ) ;
if in_generic {
new_impl_generics . extend ( quote! { ::kernel ::init ::Zeroable + } ) ;
inserted = true ;
}
}
TokenTree ::Punct ( p ) if p . as_char ( ) = = '<' = > {
nested + = 1 ;
new_impl_generics . push ( tt ) ;
}
TokenTree ::Punct ( p ) if p . as_char ( ) = = '>' = > {
assert! ( nested > 0 ) ;
nested - = 1 ;
new_impl_generics . push ( tt ) ;
}
_ = > new_impl_generics . push ( tt ) ,
}
}
assert_eq! ( nested , 0 ) ;
if in_generic & & ! inserted {
new_impl_generics . extend ( quote! { : ::kernel ::init ::Zeroable } ) ;
}
quote! {
::kernel ::__derive_zeroable! (
parse_input :
@ sig ( #( #rest ) * ) ,
@ impl_generics ( #( #new_impl_generics ) * ) ,
@ ty_generics ( #( #ty_generics ) * ) ,
@ body ( #last ) ,
) ;
}
}