[][src]Crate proc_macro_roids

Traits and functions to make writing proc macros more ergonomic.

The roids name is chosen because, although these functions make it easy to perform certain operation, they may not necessarily be a good idea =D!

Examples

  1. Append additional #[derive(..)]s.

    This works for function-like or attribute proc macros.

    This example is not tested
    extern crate proc_macro;
    
    use proc_macro::TokenStream;
    use proc_macro_roids::DeriveInputDeriveExt;
    use quote::quote;
    use syn::{parse_macro_input, parse_quote, DeriveInput};
    
    #[proc_macro_attribute]
    pub fn copy(_args: TokenStream, item: TokenStream) -> TokenStream {
        // Example input:
        //
        // #[derive(Debug)]
        // struct Struct;
        let mut ast = parse_macro_input!(item as DeriveInput);
    
        // Append the derives.
        let derives = parse_quote!(Clone, Copy);
        ast.append_derives(derives);
    
        // Example output:
        //
        // #[derive(Debug, Clone, Copy)]
        // struct Struct;
        TokenStream::from(quote! { #ast })
    }
  2. Append named fields.

    This works for structs with named fields or unit structs.

    This example is not tested
    extern crate proc_macro;
    
    use proc_macro::TokenStream;
    use proc_macro_roids::FieldsNamedAppend;
    use quote::quote;
    use syn::{parse_macro_input, parse_quote, DeriveInput, FieldsNamed};
    
    /// Example usage:
    ///
    /// ```rust
    /// use macro_crate::append_cd;
    ///
    /// #[append_cd]
    /// struct StructNamed { a: u32, b: i32 }
    /// ```
    #[proc_macro_attribute]
    pub fn append_cd(_args: TokenStream, item: TokenStream) -> TokenStream {
        // Example input:
        //
        // struct StructNamed { a: u32, b: i32 }
        let mut ast = parse_macro_input!(item as DeriveInput);
    
        // Append the fields.
        let fields_additional: FieldsNamed = parse_quote!({ c: i64, d: usize });
        ast.append_named(fields_additional);
    
        // Example output:
        //
        // struct StructNamed { a: u32, b: i32, c: i64, d: usize }
        TokenStream::from(quote! { #ast })
    }
  3. Append unnamed fields (tuples).

    This works for structs with unnamed fields or unit structs.

    This example is not tested
    extern crate proc_macro;
    
    use proc_macro::TokenStream;
    use proc_macro_roids::FieldsUnnamedAppend;
    use quote::quote;
    use syn::{parse_macro_input, parse_quote, DeriveInput, FieldsUnnamed};
    
    /// Example usage:
    ///
    /// ```rust
    /// use macro_crate::append_i64_usize;
    ///
    /// #[append_i64_usize]
    /// struct StructUnit;
    /// ```
    #[proc_macro_attribute]
    pub fn append_i64_usize(_args: TokenStream, item: TokenStream) -> TokenStream {
        // Example input:
        //
        // struct StructUnit;
        let mut ast = parse_macro_input!(item as DeriveInput);
    
        // Append the fields.
        let fields_additional: FieldsUnnamed = parse_quote!((i64, usize));
        ast.append_unnamed(fields_additional);
    
        // Example output:
        //
        // struct StructUnit(i64, usize);
        TokenStream::from(quote! { #ast })
    }
  4. Get newtype inner Field.

    This works for structs with unnamed fields or unit structs.

    This example is not tested
    extern crate proc_macro;
    
    use proc_macro::TokenStream;
    use proc_macro_roids::DeriveInputNewtypeExt;
    use quote::quote;
    use syn::{parse_macro_input, parse_quote, DeriveInput, Type};
    
    #[proc_macro_derive(Deref)]
    pub fn derive_deref(item: TokenStream) -> TokenStream {
        // Example input:
        //
        // #[derive(Deref)]
        // struct Newtype(u32);
        let mut ast = parse_macro_input!(item as DeriveInput);
    
        // Get the inner field.
        let inner_field = ast.inner_type();
    
        // Implement `Deref`
        let type_name = &ast.ident;
        let token_stream_2 = quote! {
            #ast
    
            impl std::ops::Deref for #type_name {
                type Target = #inner_type;
                fn deref(&self) -> &Self::Target {
                    &self.0
                }
            }
        }
        TokenStream::from(token_stream_2)
    }

Traits

DeriveInputDeriveExt

Functions to make it ergonomic to work with struct ASTs.

DeriveInputNewtypeExt

Functions to make it ergonomic to work with newtype struct ASTs.

DeriveInputStructExt

Functions to make it ergonomic to work with struct ASTs.

FieldsNamedAppend

Indicates this type may have FieldsNamed appended to it.

FieldsUnnamedAppend

Indicates this type may have FieldsUnnamed appended to it.

Functions

ident_concat

Returns an Ident by concatenating String representations.

meta_list_contains

Returns whether the MetaList contains the specified NestedMeta.

nested_meta_to_ident

Returns the Ident of a nested meta. If it is a literal, None is returned.