This works for function-like or attribute proc macros.

extern crate proc_macro;

use proc_macro::TokenStream;
use proc_macro_roids::DeriveInputExt;
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 })
}

This works for structs with named fields or unit structs.

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 })
}

This works for structs with unnamed fields or unit structs.

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 })
}

This works for structs with unnamed fields or unit structs.

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 type.
    let inner_type = 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)
}

use proc_macro_roids::IdentExt;
use proc_macro2::Span;
use syn::Ident;

# fn main() {
let one = Ident::new("One", Span::call_site());
assert_eq!(Ident::new("OneSuffix", Span::call_site()), one.append("Suffix"));
assert_eq!(Ident::new("PrefixOne", Span::call_site()), one.prepend("Prefix"));

let two = Ident::new("Two", Span::call_site());
assert_eq!(Ident::new("OneTwo", Span::call_site()), one.append(&two));
assert_eq!(Ident::new("TwoOne", Span::call_site()), one.prepend(&two));
# }

use proc_macro_roids::DeriveInputStructExt;
use syn::{parse_quote, DeriveInput, Fields};

# fn main() {
let ast: DeriveInput = parse_quote! {
    struct Named {}
};

if let Fields::Named(..) = ast.fields() {
    // do something
}
# }

use proc_macro_roids::FieldExt;
use proc_macro2::Span;
use syn::{parse_quote, Fields, FieldsNamed, Lit, LitStr, Meta, MetaNameValue, NestedMeta};

let fields_named: FieldsNamed = parse_quote! {{
    #[my::derive(tag::name(param = "value"))]
    pub name: PhantomData<T>,
}};
let fields = Fields::from(fields_named);
let field = fields.iter().next().expect("Expected field to exist.");

assert_eq!(field.type_name(), "PhantomData");
assert!(field.is_phantom_data());
assert!(field.contains_tag(&parse_quote!(my::derive), &parse_quote!(tag::name)));
assert_eq!(
    field.tag_parameter(
        &parse_quote!(my::derive),
        &parse_quote!(tag::name),
    ).expect("Expected parameter to exist."),
    NestedMeta::Meta(Meta::NameValue(MetaNameValue {
        path: parse_quote!(param),
        eq_token: Default::default(),
        lit: Lit::Str(LitStr::new("value", Span::call_site())),
    })),
);

# use std::str::FromStr;
#
use proc_macro_roids::{DeriveInputStructExt, FieldsExt};
# use proc_macro2::{Span, TokenStream};
# use syn::{parse_quote, DeriveInput};
# use quote::quote;
#
// Need to generate code that instantiates `MyEnum::Struct`:
// enum MyEnum {
//     Struct {
//         field_0: u32,
//         field_1: u32,
//     }
// }

let ast: DeriveInput = parse_quote! {
    struct Struct {
        field_0: u32,
        field_1: u32,
    }
};
let fields = ast.fields();
let construction_form = fields.construction_form();
let tokens = quote! { MyEnum::Struct #construction_form };

let expected = TokenStream::from_str("MyEnum::Struct { field_0, field_1, }").unwrap();
assert_eq!(expected.to_string(), tokens.to_string());