Rust: using derive inside macro - rust

Question

i have a question on rust macros... i created a custom trait, and i made it derivable...
but now if i try to derive the trait inside a macro it doesn't work (but if i write it manually it does work)
here is the code:
// this is my macro
#[macro_export]
macro_rules! compact {
( $x:ident, $y:ident ) => {
#[derive(Vhdlizable,Debug)]
struct Compact<T,E>{
$x: T,
$y: E
}
};
}
#[test]
fn test_compact_macro(){
let a = 11_i32;
let b = 0_u8;
//this dos't work
//compact!(a,b);
//this works
#[derive(Vhdlizable,Debug)]
struct Compact<T, E,> {
a: T,
b: E,
}
}
the error i get is the following:
error[E0424]: expected value, found module `self`
--> src\tests.rs:103:14
|
90 | #[derive(Vhdlizable,Debug)]
| ---------- this function has a `self` parameter, but a macro invocation can only access identifiers it receives from parameters
...
103 | compact!(a,b);
| ^ `self` value is a keyword only available in methods with a `self` parameter
i have no idea what could cause this...
it should be noted that if i only derive the Debug trait it works
here is the code to make the trait Derivable:
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,
};
#[test]
fn test(){
}
#[proc_macro_derive(Vhdlizable)]
pub fn derive_vhdliizable(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();
let necessary_bits = sum_necessary_bits(&input.data);
let bit_rapresentation = concat_bit_representation(&input.data);
let declaration_code = generate_delcaration_code(&input.data);
let construction_code = generate_construction_code(&input.data);
let deconstruction_code = generate_deconstruction_code(&input.data);
let recreate_from_bits_code = generate_recursive_reconstruction(&input.data);
let expanded = quote! {
// The generated impl.
impl #impl_generics Vhdlizable for #name #ty_generics #where_clause {
fn get_necessary_bits() -> usize{
#necessary_bits
}
fn get_bit_representation(&self) -> Vec<bool>{
#bit_rapresentation
}
fn construct_from_bits(data: &[bool]) -> Result<Self,std::io::Error> where Self: Sized{
if data.len() != Self::get_necessary_bits(){
return Err(std::io::Error::new(std::io::ErrorKind::Other, "Length of input incompatible with length of output"));
};
#recreate_from_bits_code
}
fn get_vhd_construction_code(variable_name: &str ,start_index: usize) -> String{
#construction_code
}
fn get_vhd_declaration_code(variable_name: &str ) -> String{
#declaration_code
}
fn get_vhd_deconstruction_code(variable_name: &str ,start_index: usize) -> String{
#deconstruction_code
}
}
};
// Hand the output tokens back to the compiler.
proc_macro::TokenStream::from(expanded)
}
// Add a bound `T: Vhdlizable` 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!(Vhdlizable));
}
}
generics
}
// Generate an expression to sum up the heap size of each field.
fn sum_necessary_bits(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
let recurse = fields.named.iter().map(|f| {
let type_ = &f.ty;
quote_spanned! {f.span()=>
#type_::get_necessary_bits()
}
});
quote! {
0 #(+ #recurse)*
}
}
Fields::Unnamed(_) => {
unimplemented!("Impossible to derive this trait on unnamed Type")
}
Fields::Unit => {
unimplemented!("Impossible to derive this trait on unit Type")
}
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
fn concat_bit_representation(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
let recurse: Vec<_> = fields.named.iter().map(|f| {
let name = &f.ident;
quote_spanned! {f.span()=>
self.#name.get_bit_representation()
}
}).collect();
quote! {
let mut v = vec![false;0];
#(v.extend(#recurse);)*
v
}
}
Fields::Unnamed(_) => {
unimplemented!("Impossible to derive this trait on unnamed Type")
}
Fields::Unit => {
unimplemented!("Impossible to derive this trait on unit Type")
}
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
fn generate_delcaration_code(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
let recurse: Vec<_> = fields.named.iter().map(|f| {
let name = &f.ident;
let type_ = &f.ty;
quote_spanned! {f.span()=>
//self.#name.get_delcaration_code("name")
#type_::get_vhd_declaration_code(
&format!("{}_{}",variable_name,stringify!(#name))[..]
)
}
}).collect();
quote! {
let mut s = String::new();
#(s.push_str(&(#recurse)[..]);)*
s
}
}
Fields::Unnamed(_) => {
unimplemented!("Impossible to derive this trait on unnamed Type")
}
Fields::Unit => {
unimplemented!("Impossible to derive this trait on unit Type")
}
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
fn generate_construction_code(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
let recurse: Vec<_> = fields.named.iter().map(|f| {
let name = &f.ident;
let type_ = &f.ty;
quote_spanned! {f.span()=>
#type_::get_vhd_construction_code(
&format!("{}_{}",variable_name,stringify!(#name))[..],
start_from
)
}
}).collect();
let sizes: Vec<_> = fields.named.iter().map(|f| {
let type_ = &f.ty;
quote_spanned! {f.span()=>
#type_::get_necessary_bits()
}
}).collect();
quote! {
let mut start_from = start_index;
let mut s = String::new();
#(
s.push_str(&(#recurse)[..]);
start_from += #sizes;
)*
s
}
}
Fields::Unnamed(_) => {
unimplemented!("Impossible to derive this trait on unnamed Type")
}
Fields::Unit => {
unimplemented!("Impossible to derive this trait on unit Type")
}
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
fn generate_deconstruction_code(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
let recurse: Vec<_> = fields.named.iter().map(|f| {
let name = &f.ident;
let type_ = &f.ty;
quote_spanned! {f.span()=>
#type_::get_vhd_deconstruction_code(
&format!("{}_{}",variable_name,stringify!(#name))[..],
start_from
)
}
}).collect();
let sizes: Vec<_> = fields.named.iter().map(|f| {
let type_ = &f.ty;
quote_spanned! {f.span()=>
#type_::get_necessary_bits()
}
}).collect();
quote! {
let mut start_from = start_index;
let mut s = String::new();
#(
s.push_str(&(#recurse)[..]);
start_from += #sizes;
)*
s
}
}
Fields::Unnamed(_) => {
unimplemented!("Impossible to derive this trait on unnamed Type")
}
Fields::Unit => {
unimplemented!("Impossible to derive this trait on unit Type")
}
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}
fn generate_recursive_reconstruction(data: &Data) -> TokenStream {
match *data {
Data::Struct(ref data) => {
match data.fields {
Fields::Named(ref fields) => {
let recurse: Vec<_> = fields.named.iter().map(|f| {
let name = &f.ident;
let type_ = &f.ty;
quote_spanned! {f.span()=>
let n = #type_::get_necessary_bits();
let v = &data[counter..(counter+n)];
counter += n;
let #name: #type_ = #type_::construct_from_bits(v)?;
}
}).collect();
let names: Vec<_> = fields.named.iter().map(|f| {
let name = &f.ident;
quote_spanned! {f.span()=>
#name
}
}).collect();
quote! {
let mut counter = 0_usize;
#(
#recurse
)*
Ok(Self{
#(
#names,
)*
})
}
}
Fields::Unnamed(_) => {
unimplemented!("Impossible to derive this trait on unnamed Type")
}
Fields::Unit => {
unimplemented!("Impossible to derive this trait on unit Type")
}
}
}
Data::Enum(_) | Data::Union(_) => unimplemented!(),
}
}

Answer 1

i switch to nightly rust to expand the code... and it works now...
if you are still interested in or, here is the expanded code:
#[allow(unused_imports)]
#[allow(dead_code)]
mod tests {
use std::fmt::Debug;
#[allow(unused_imports)]
use crate::communicate_to_vhdl::{Communicator, Vhdlizable};
fn test_compact_macro() {
let a = 11_i32;
let b = 0_u8;
struct Compact<T, E> {
a: T,
b: E,
}
impl<T: Vhdlizable, E: Vhdlizable> Vhdlizable for Compact<T, E> {
fn get_necessary_bits() -> usize {
0 + T::get_necessary_bits() + E::get_necessary_bits()
}
fn get_bit_representation(&self) -> Vec<bool> {
let mut v = ::alloc::vec::from_elem(false, 0);
v.extend(self.a.get_bit_representation());
v.extend(self.b.get_bit_representation());
v
}
fn construct_from_bits(data: &[bool]) -> Result<Self, std::io::Error>
where
Self: Sized,
{
if data.len() != Self::get_necessary_bits() {
return Err(
std::io::Error::new(
std::io::ErrorKind::Other,
"Length of input incompatible with length of output",
),
);
}
let mut counter = 0_usize;
let n = T::get_necessary_bits();
let v = &data[counter..(counter + n)];
counter += n;
let a: T = T::construct_from_bits(v)?;
let n = E::get_necessary_bits();
let v = &data[counter..(counter + n)];
counter += n;
let b: E = E::construct_from_bits(v)?;
Ok(Self { a, b })
}
fn get_vhd_construction_code(
variable_name: &str,
start_index: usize,
) -> String {
let mut start_from = start_index;
let mut s = String::new();
s.push_str(
&(T::get_vhd_construction_code(
&{
let res = ::alloc::fmt::format(
format_args!("{0}_{1}", variable_name, "a"),
);
res
}[..],
start_from,
))[..],
);
start_from += T::get_necessary_bits();
s.push_str(
&(E::get_vhd_construction_code(
&{
let res = ::alloc::fmt::format(
format_args!("{0}_{1}", variable_name, "b"),
);
res
}[..],
start_from,
))[..],
);
start_from += E::get_necessary_bits();
s
}
fn get_vhd_declaration_code(variable_name: &str) -> String {
let mut s = String::new();
s.push_str(
&(T::get_vhd_declaration_code(
&{
let res = ::alloc::fmt::format(
format_args!("{0}_{1}", variable_name, "a"),
);
res
}[..],
))[..],
);
s.push_str(
&(E::get_vhd_declaration_code(
&{
let res = ::alloc::fmt::format(
format_args!("{0}_{1}", variable_name, "b"),
);
res
}[..],
))[..],
);
s
}
fn get_vhd_deconstruction_code(
variable_name: &str,
start_index: usize,
) -> String {
let mut start_from = start_index;
let mut s = String::new();
s.push_str(
&(T::get_vhd_deconstruction_code(
&{
let res = ::alloc::fmt::format(
format_args!("{0}_{1}", variable_name, "a"),
);
res
}[..],
start_from,
))[..],
"Compact",
"a",
&self.a,
"b",
&&self.b,
)
}
}
}
}