typing

command_attributes/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "regex_command_attr"
+version = "0.3.6"
+authors = ["acdenisSK <acdenissk69@gmail.com>", "jellywx <judesouthworth@pm.me>"]
+edition = "2018"
+description = "Procedural macros for command creation for the Serenity library."
+license = "ISC"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "^1.0"
+syn = { version = "^1.0", features = ["full", "derive", "extra-traits"] }
+proc-macro2 = "1.0"

command_attributes/src/attributes.rs

@@ -0,0 +1,400 @@
+use std::fmt::{self, Write};
+
+use proc_macro2::Span;
+use syn::{
+    parse::{Error, Result},
+    spanned::Spanned,
+    Attribute, Ident, Lit, LitStr, Meta, NestedMeta, Path,
+};
+
+use crate::{
+    structures::{ApplicationCommandOptionType, Arg, PermissionLevel},
+    util::{AsOption, LitExt},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ValueKind {
+    // #[<name>]
+    Name,
+
+    // #[<name> = <value>]
+    Equals,
+
+    // #[<name>([<value>, <value>, <value>, ...])]
+    List,
+
+    // #[<name>([<prop> = <value>, <prop> = <value>, ...])]
+    EqualsList,
+
+    // #[<name>(<value>)]
+    SingleList,
+}
+
+impl fmt::Display for ValueKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ValueKind::Name => f.pad("`#[<name>]`"),
+            ValueKind::Equals => f.pad("`#[<name> = <value>]`"),
+            ValueKind::List => f.pad("`#[<name>([<value>, <value>, <value>, ...])]`"),
+            ValueKind::EqualsList => {
+                f.pad("`#[<name>([<prop> = <value>, <prop> = <value>, ...])]`")
+            }
+            ValueKind::SingleList => f.pad("`#[<name>(<value>)]`"),
+        }
+    }
+}
+
+fn to_ident(p: Path) -> Result<Ident> {
+    if p.segments.is_empty() {
+        return Err(Error::new(
+            p.span(),
+            "cannot convert an empty path to an identifier",
+        ));
+    }
+
+    if p.segments.len() > 1 {
+        return Err(Error::new(
+            p.span(),
+            "the path must not have more than one segment",
+        ));
+    }
+
+    if !p.segments[0].arguments.is_empty() {
+        return Err(Error::new(
+            p.span(),
+            "the singular path segment must not have any arguments",
+        ));
+    }
+
+    Ok(p.segments[0].ident.clone())
+}
+
+#[derive(Debug)]
+pub struct Values {
+    pub name: Ident,
+    pub literals: Vec<(Option<String>, Lit)>,
+    pub kind: ValueKind,
+    pub span: Span,
+}
+
+impl Values {
+    #[inline]
+    pub fn new(
+        name: Ident,
+        kind: ValueKind,
+        literals: Vec<(Option<String>, Lit)>,
+        span: Span,
+    ) -> Self {
+        Values {
+            name,
+            literals,
+            kind,
+            span,
+        }
+    }
+}
+
+pub fn parse_values(attr: &Attribute) -> Result<Values> {
+    fn is_list_or_named_list(meta: &NestedMeta) -> ValueKind {
+        match meta {
+            // catch if the nested value is a literal value
+            NestedMeta::Lit(_) => ValueKind::List,
+            // catch if the nested value is a meta value
+            NestedMeta::Meta(m) => match m {
+                // path => some quoted value
+                Meta::Path(_) => ValueKind::List,
+                Meta::List(_) | Meta::NameValue(_) => ValueKind::EqualsList,
+            },
+        }
+    }
+
+    let meta = attr.parse_meta()?;
+
+    match meta {
+        Meta::Path(path) => {
+            let name = to_ident(path)?;
+
+            Ok(Values::new(name, ValueKind::Name, Vec::new(), attr.span()))
+        }
+        Meta::List(meta) => {
+            let name = to_ident(meta.path)?;
+            let nested = meta.nested;
+
+            if nested.is_empty() {
+                return Err(Error::new(attr.span(), "list cannot be empty"));
+            }
+
+            if is_list_or_named_list(nested.first().unwrap()) == ValueKind::List {
+                let mut lits = Vec::with_capacity(nested.len());
+
+                for meta in nested {
+                    match meta {
+                        // catch if the nested value is a literal value
+                        NestedMeta::Lit(l) => lits.push((None, l)),
+                        // catch if the nested value is a meta value
+                        NestedMeta::Meta(m) => match m {
+                            // path => some quoted value
+                            Meta::Path(path) => {
+                                let i = to_ident(path)?;
+                                lits.push((None, Lit::Str(LitStr::new(&i.to_string(), i.span()))))
+                            }
+                            Meta::List(_) | Meta::NameValue(_) => {
+                                return Err(Error::new(attr.span(), "cannot nest a list; only accept literals and identifiers at this level"))
+                            }
+                        },
+                    }
+                }
+
+                let kind = if lits.len() == 1 {
+                    ValueKind::SingleList
+                } else {
+                    ValueKind::List
+                };
+
+                Ok(Values::new(name, kind, lits, attr.span()))
+            } else {
+                let mut lits = Vec::with_capacity(nested.len());
+
+                for meta in nested {
+                    match meta {
+                        // catch if the nested value is a literal value
+                        NestedMeta::Lit(_) => {
+                            return Err(Error::new(attr.span(), "key-value pairs expected"))
+                        }
+                        // catch if the nested value is a meta value
+                        NestedMeta::Meta(m) => match m {
+                            Meta::NameValue(n) => {
+                                let name = to_ident(n.path)?.to_string();
+                                let value = n.lit;
+
+                                lits.push((Some(name), value));
+                            }
+                            Meta::List(_) | Meta::Path(_) => {
+                                return Err(Error::new(attr.span(), "key-value pairs expected"))
+                            }
+                        },
+                    }
+                }
+
+                Ok(Values::new(name, ValueKind::EqualsList, lits, attr.span()))
+            }
+        }
+        Meta::NameValue(meta) => {
+            let name = to_ident(meta.path)?;
+            let lit = meta.lit;
+
+            Ok(Values::new(
+                name,
+                ValueKind::Equals,
+                vec![(None, lit)],
+                attr.span(),
+            ))
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct DisplaySlice<'a, T>(&'a [T]);
+
+impl<'a, T: fmt::Display> fmt::Display for DisplaySlice<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut iter = self.0.iter().enumerate();
+
+        match iter.next() {
+            None => f.write_str("nothing")?,
+            Some((idx, elem)) => {
+                write!(f, "{}: {}", idx, elem)?;
+
+                for (idx, elem) in iter {
+                    f.write_char('\n')?;
+                    write!(f, "{}: {}", idx, elem)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[inline]
+fn is_form_acceptable(expect: &[ValueKind], kind: ValueKind) -> bool {
+    if expect.contains(&ValueKind::List) && kind == ValueKind::SingleList {
+        true
+    } else {
+        expect.contains(&kind)
+    }
+}
+
+#[inline]
+fn validate(values: &Values, forms: &[ValueKind]) -> Result<()> {
+    if !is_form_acceptable(forms, values.kind) {
+        return Err(Error::new(
+            values.span,
+            // Using the `_args` version here to avoid an allocation.
+            format_args!(
+                "the attribute must be in of these forms:\n{}",
+                DisplaySlice(forms)
+            ),
+        ));
+    }
+
+    Ok(())
+}
+
+#[inline]
+pub fn parse<T: AttributeOption>(values: Values) -> Result<T> {
+    T::parse(values)
+}
+
+pub trait AttributeOption: Sized {
+    fn parse(values: Values) -> Result<Self>;
+}
+
+impl AttributeOption for Vec<String> {
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::List])?;
+
+        Ok(values
+            .literals
+            .into_iter()
+            .map(|(_, l)| l.to_str())
+            .collect())
+    }
+}
+
+impl AttributeOption for String {
+    #[inline]
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::Equals, ValueKind::SingleList])?;
+
+        Ok(values.literals[0].1.to_str())
+    }
+}
+
+impl AttributeOption for bool {
+    #[inline]
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::Name, ValueKind::SingleList])?;
+
+        Ok(values.literals.get(0).map_or(true, |(_, l)| l.to_bool()))
+    }
+}
+
+impl AttributeOption for Ident {
+    #[inline]
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::SingleList])?;
+
+        Ok(values.literals[0].1.to_ident())
+    }
+}
+
+impl AttributeOption for Vec<Ident> {
+    #[inline]
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::List])?;
+
+        Ok(values
+            .literals
+            .into_iter()
+            .map(|(_, l)| l.to_ident())
+            .collect())
+    }
+}
+
+impl AttributeOption for Option<String> {
+    fn parse(values: Values) -> Result<Self> {
+        validate(
+            &values,
+            &[ValueKind::Name, ValueKind::Equals, ValueKind::SingleList],
+        )?;
+
+        Ok(values.literals.get(0).map(|(_, l)| l.to_str()))
+    }
+}
+
+impl AttributeOption for PermissionLevel {
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::SingleList])?;
+
+        Ok(values
+            .literals
+            .get(0)
+            .map(|(_, l)| PermissionLevel::from_str(&*l.to_str()).unwrap())
+            .unwrap())
+    }
+}
+
+impl AttributeOption for Arg {
+    fn parse(values: Values) -> Result<Self> {
+        validate(&values, &[ValueKind::EqualsList])?;
+
+        let mut arg: Arg = Default::default();
+
+        for (key, value) in &values.literals {
+            match key {
+                Some(s) => match s.as_str() {
+                    "name" => {
+                        arg.name = value.to_str();
+                    }
+                    "description" => {
+                        arg.description = value.to_str();
+                    }
+                    "required" => {
+                        arg.required = value.to_bool();
+                    }
+                    "kind" => arg.kind = ApplicationCommandOptionType::from_str(value.to_str()),
+                    _ => {
+                        return Err(Error::new(key.span(), "unexpected attribute"));
+                    }
+                },
+                _ => {
+                    return Err(Error::new(key.span(), "unnamed attribute"));
+                }
+            }
+        }
+
+        Ok(arg)
+    }
+}
+
+impl<T: AttributeOption> AttributeOption for AsOption<T> {
+    #[inline]
+    fn parse(values: Values) -> Result<Self> {
+        Ok(AsOption(Some(T::parse(values)?)))
+    }
+}
+
+macro_rules! attr_option_num {
+    ($($n:ty),*) => {
+        $(
+            impl AttributeOption for $n {
+                fn parse(values: Values) -> Result<Self> {
+                    validate(&values, &[ValueKind::SingleList])?;
+
+                    Ok(match &values.literals[0].1 {
+                        Lit::Int(l) => l.base10_parse::<$n>()?,
+                        l => {
+                            let s = l.to_str();
+                            // Use `as_str` to guide the compiler to use `&str`'s parse method.
+                            // We don't want to use our `parse` method here (`impl AttributeOption for String`).
+                            match s.as_str().parse::<$n>() {
+                                Ok(n) => n,
+                                Err(_) => return Err(Error::new(l.span(), "invalid integer")),
+                            }
+                        }
+                    })
+                }
+            }
+
+            impl AttributeOption for Option<$n> {
+                #[inline]
+                fn parse(values: Values) -> Result<Self> {
+                    <$n as AttributeOption>::parse(values).map(Some)
+                }
+            }
+        )*
+    }
+}
+
+attr_option_num!(u16, u32, usize);

command_attributes/src/consts.rs

@@ -0,0 +1,7 @@
+pub mod suffixes {
+    pub const COMMAND: &str = "COMMAND";
+    pub const ARG: &str = "ARG";
+    pub const SUBCOMMAND: &str = "SUBCOMMAND";
+}
+
+pub use self::suffixes::*;

command_attributes/src/lib.rs

@@ -0,0 +1,258 @@
+#![deny(rust_2018_idioms)]
+#![deny(broken_intra_doc_links)]
+
+use proc_macro::TokenStream;
+use proc_macro2::Ident;
+use quote::quote;
+use syn::{parse::Error, parse_macro_input, parse_quote, spanned::Spanned, Lit, Type};
+
+pub(crate) mod attributes;
+pub(crate) mod consts;
+pub(crate) mod structures;
+
+#[macro_use]
+pub(crate) mod util;
+
+use attributes::*;
+use consts::*;
+use structures::*;
+use util::*;
+
+macro_rules! match_options {
+    ($v:expr, $values:ident, $options:ident, $span:expr => [$($name:ident);*]) => {
+        match $v {
+            $(
+                stringify!($name) => $options.$name = propagate_err!($crate::attributes::parse($values)),
+            )*
+            _ => {
+                return Error::new($span, format_args!("invalid attribute: {:?}", $v))
+                    .to_compile_error()
+                    .into();
+            },
+        }
+    };
+}
+
+#[proc_macro_attribute]
+pub fn command(attr: TokenStream, input: TokenStream) -> TokenStream {
+    let mut fun = parse_macro_input!(input as CommandFun);
+
+    let _name = if !attr.is_empty() {
+        parse_macro_input!(attr as Lit).to_str()
+    } else {
+        fun.name.to_string()
+    };
+
+    let mut options = Options::new();
+
+    for attribute in &fun.attributes {
+        let span = attribute.span();
+        let values = propagate_err!(parse_values(attribute));
+
+        let name = values.name.to_string();
+        let name = &name[..];
+
+        match name {
+            "subcommand" => {
+                options
+                    .subcommands
+                    .push(Subcommand::new(propagate_err!(attributes::parse(values))));
+            }
+            "arg" => {
+                if let Some(subcommand) = options.subcommands.last_mut() {
+                    subcommand.cmd_args.push(propagate_err!(attributes::parse(values)));
+                } else {
+                    options.cmd_args.push(propagate_err!(attributes::parse(values)));
+                }
+            }
+            "example" => {
+                options.examples.push(propagate_err!(attributes::parse(values)));
+            }
+            "description" => {
+                let line: String = propagate_err!(attributes::parse(values));
+                if let Some(subcommand) = options.subcommands.last_mut() {
+                    util::append_line(&mut subcommand.description, line);
+                } else {
+                    util::append_line(&mut options.description, line);
+                }
+            }
+            _ => {
+                match_options!(name, values, options, span => [
+                    aliases;
+                    group;
+                    required_permissions;
+                    can_blacklist;
+                    supports_dm
+                ]);
+            }
+        }
+    }
+
+    let Options {
+        aliases,
+        description,
+        group,
+        examples,
+        required_permissions,
+        can_blacklist,
+        supports_dm,
+        mut cmd_args,
+        mut subcommands,
+    } = options;
+
+    let visibility = fun.visibility;
+    let name = fun.name.clone();
+    let body = fun.body;
+
+    let n = name.with_suffix(COMMAND);
+
+    let cooked = fun.cooked.clone();
+
+    let command_path = quote!(crate::framework::Command);
+    let arg_path = quote!(crate::framework::Arg);
+    let subcommand_path = ApplicationCommandOptionType::SubCommand;
+
+    populate_fut_lifetimes_on_refs(&mut fun.args);
+    let args = fun.args;
+
+    let mut subcommand_idents = subcommands
+        .iter()
+        .map(|subcommand| {
+            n.with_suffix(subcommand.name.replace("-", "_").as_str()).with_suffix(SUBCOMMAND)
+        })
+        .collect::<Vec<Ident>>();
+
+    let mut tokens = subcommands
+        .iter_mut()
+        .zip(subcommand_idents.iter())
+        .map(|(subcommand, sc_ident)| {
+            let arg_idents = subcommand
+                .cmd_args
+                .iter()
+                .map(|arg| {
+                    n.with_suffix(subcommand.name.as_str())
+                        .with_suffix(arg.name.as_str())
+                        .with_suffix(ARG)
+                })
+                .collect::<Vec<Ident>>();
+
+            let mut tokens = subcommand
+                .cmd_args
+                .iter_mut()
+                .zip(arg_idents.iter())
+                .map(|(arg, ident)| {
+                    let Arg { name, description, kind, required } = arg;
+
+                    quote! {
+                        #(#cooked)*
+                        #[allow(missing_docs)]
+                        pub static #ident: #arg_path = #arg_path {
+                            name: #name,
+                            description: #description,
+                            kind: #kind,
+                            required: #required,
+                            options: &[]
+                        };
+                    }
+                })
+                .fold(quote! {}, |mut a, b| {
+                    a.extend(b);
+                    a
+                });
+
+            let Subcommand { name, description, .. } = subcommand;
+
+            tokens.extend(quote! {
+                #(#cooked)*
+                #[allow(missing_docs)]
+                pub static #sc_ident: #arg_path = #arg_path {
+                    name: #name,
+                    description: #description,
+                    kind: #subcommand_path,
+                    required: false,
+                    options: &[#(&#arg_idents),*],
+                };
+            });
+
+            tokens
+        })
+        .fold(quote! {}, |mut a, b| {
+            a.extend(b);
+            a
+        });
+
+    let mut arg_idents = cmd_args
+        .iter()
+        .map(|arg| n.with_suffix(arg.name.replace("-", "_").as_str()).with_suffix(ARG))
+        .collect::<Vec<Ident>>();
+
+    let arg_tokens = cmd_args
+        .iter_mut()
+        .zip(arg_idents.iter())
+        .map(|(arg, ident)| {
+            let Arg { name, description, kind, required } = arg;
+
+            quote! {
+                #(#cooked)*
+                #[allow(missing_docs)]
+                pub static #ident: #arg_path = #arg_path {
+                    name: #name,
+                    description: #description,
+                    kind: #kind,
+                    required: #required,
+                    options: &[],
+                };
+            }
+        })
+        .fold(quote! {}, |mut a, b| {
+            a.extend(b);
+            a
+        });
+
+    tokens.extend(arg_tokens);
+    arg_idents.append(&mut subcommand_idents);
+
+    let variant = if args.len() == 2 {
+        quote!(crate::framework::CommandFnType::Multi)
+    } else {
+        let string: Type = parse_quote!(String);
+
+        let final_arg = args.get(2).unwrap();
+
+        if final_arg.kind == string {
+            quote!(crate::framework::CommandFnType::Text)
+        } else {
+            quote!(crate::framework::CommandFnType::Slash)
+        }
+    };
+
+    tokens.extend(quote! {
+        #(#cooked)*
+        #[allow(missing_docs)]
+        pub static #n: #command_path = #command_path {
+            fun: #variant(#name),
+            names: &[#_name, #(#aliases),*],
+            desc: #description,
+            group: #group,
+            examples: &[#(#examples),*],
+            required_permissions: #required_permissions,
+            can_blacklist: #can_blacklist,
+            supports_dm: #supports_dm,
+            args: &[#(&#arg_idents),*],
+        };
+    });
+
+    tokens.extend(quote! {
+        #(#cooked)*
+        #[allow(missing_docs)]
+        #visibility fn #name<'fut> (#(#args),*) -> ::serenity::futures::future::BoxFuture<'fut, ()> {
+            use ::serenity::futures::future::FutureExt;
+
+            async move {
+                #(#body)*;
+            }.boxed()
+        }
+    });
+
+    tokens.into()
+}

command_attributes/src/structures.rs

@@ -0,0 +1,287 @@
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{quote, ToTokens};
+use syn::{
+    braced,
+    parse::{Error, Parse, ParseStream, Result},
+    spanned::Spanned,
+    Attribute, Block, FnArg, Ident, Pat, Stmt, Token, Visibility,
+};
+
+use crate::util::{Argument, Parenthesised};
+
+fn parse_argument(arg: FnArg) -> Result<Argument> {
+    match arg {
+        FnArg::Typed(typed) => {
+            let pat = typed.pat;
+            let kind = typed.ty;
+
+            match *pat {
+                Pat::Ident(id) => {
+                    let name = id.ident;
+                    let mutable = id.mutability;
+
+                    Ok(Argument { mutable, name, kind: *kind })
+                }
+                Pat::Wild(wild) => {
+                    let token = wild.underscore_token;
+
+                    let name = Ident::new("_", token.spans[0]);
+
+                    Ok(Argument { mutable: None, name, kind: *kind })
+                }
+                _ => Err(Error::new(pat.span(), format_args!("unsupported pattern: {:?}", pat))),
+            }
+        }
+        FnArg::Receiver(_) => {
+            Err(Error::new(arg.span(), format_args!("`self` arguments are prohibited: {:?}", arg)))
+        }
+    }
+}
+
+/// Test if the attribute is cooked.
+fn is_cooked(attr: &Attribute) -> bool {
+    const COOKED_ATTRIBUTE_NAMES: &[&str] =
+        &["cfg", "cfg_attr", "derive", "inline", "allow", "warn", "deny", "forbid"];
+
+    COOKED_ATTRIBUTE_NAMES.iter().any(|n| attr.path.is_ident(n))
+}
+
+/// Removes cooked attributes from a vector of attributes. Uncooked attributes are left in the vector.
+///
+/// # Return
+///
+/// Returns a vector of cooked attributes that have been removed from the input vector.
+fn remove_cooked(attrs: &mut Vec<Attribute>) -> Vec<Attribute> {
+    let mut cooked = Vec::new();
+
+    // FIXME: Replace with `Vec::drain_filter` once it is stable.
+    let mut i = 0;
+    while i < attrs.len() {
+        if !is_cooked(&attrs[i]) {
+            i += 1;
+            continue;
+        }
+
+        cooked.push(attrs.remove(i));
+    }
+
+    cooked
+}
+
+#[derive(Debug)]
+pub struct CommandFun {
+    /// `#[...]`-style attributes.
+    pub attributes: Vec<Attribute>,
+    /// Populated cooked attributes. These are attributes outside of the realm of this crate's procedural macros
+    /// and will appear in generated output.
+    pub cooked: Vec<Attribute>,
+    pub visibility: Visibility,
+    pub name: Ident,
+    pub args: Vec<Argument>,
+    pub body: Vec<Stmt>,
+}
+
+impl Parse for CommandFun {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let mut attributes = input.call(Attribute::parse_outer)?;
+
+        let cooked = remove_cooked(&mut attributes);
+
+        let visibility = input.parse::<Visibility>()?;
+
+        input.parse::<Token![async]>()?;
+
+        input.parse::<Token![fn]>()?;
+        let name = input.parse()?;
+
+        // (...)
+        let Parenthesised(args) = input.parse::<Parenthesised<FnArg>>()?;
+
+        // { ... }
+        let bcont;
+        braced!(bcont in input);
+        let body = bcont.call(Block::parse_within)?;
+
+        let args = args.into_iter().map(parse_argument).collect::<Result<Vec<_>>>()?;
+
+        Ok(Self { attributes, cooked, visibility, name, args, body })
+    }
+}
+
+impl ToTokens for CommandFun {
+    fn to_tokens(&self, stream: &mut TokenStream2) {
+        let Self { attributes: _, cooked, visibility, name, args, body } = self;
+
+        stream.extend(quote! {
+            #(#cooked)*
+            #visibility async fn #name (#(#args),*) {
+                #(#body)*
+            }
+        });
+    }
+}
+
+#[derive(Debug)]
+pub enum PermissionLevel {
+    Unrestricted,
+    Managed,
+    Restricted,
+}
+
+impl Default for PermissionLevel {
+    fn default() -> Self {
+        Self::Unrestricted
+    }
+}
+
+impl PermissionLevel {
+    pub fn from_str(s: &str) -> Option<Self> {
+        Some(match s.to_uppercase().as_str() {
+            "UNRESTRICTED" => Self::Unrestricted,
+            "MANAGED" => Self::Managed,
+            "RESTRICTED" => Self::Restricted,
+            _ => return None,
+        })
+    }
+}
+
+impl ToTokens for PermissionLevel {
+    fn to_tokens(&self, stream: &mut TokenStream2) {
+        let path = quote!(crate::framework::PermissionLevel);
+        let variant;
+
+        match self {
+            Self::Unrestricted => {
+                variant = quote!(Unrestricted);
+            }
+
+            Self::Managed => {
+                variant = quote!(Managed);
+            }
+
+            Self::Restricted => {
+                variant = quote!(Restricted);
+            }
+        }
+
+        stream.extend(quote! {
+            #path::#variant
+        });
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum ApplicationCommandOptionType {
+    SubCommand,
+    SubCommandGroup,
+    String,
+    Integer,
+    Boolean,
+    User,
+    Channel,
+    Role,
+    Mentionable,
+    Number,
+    Unknown,
+}
+
+impl ApplicationCommandOptionType {
+    pub fn from_str(s: String) -> Self {
+        match s.as_str() {
+            "SubCommand" => Self::SubCommand,
+            "SubCommandGroup" => Self::SubCommandGroup,
+            "String" => Self::String,
+            "Integer" => Self::Integer,
+            "Boolean" => Self::Boolean,
+            "User" => Self::User,
+            "Channel" => Self::Channel,
+            "Role" => Self::Role,
+            "Mentionable" => Self::Mentionable,
+            "Number" => Self::Number,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl ToTokens for ApplicationCommandOptionType {
+    fn to_tokens(&self, stream: &mut TokenStream2) {
+        let path = quote!(
+            serenity::model::interactions::application_command::ApplicationCommandOptionType
+        );
+        let variant = match self {
+            ApplicationCommandOptionType::SubCommand => quote!(SubCommand),
+            ApplicationCommandOptionType::SubCommandGroup => quote!(SubCommandGroup),
+            ApplicationCommandOptionType::String => quote!(String),
+            ApplicationCommandOptionType::Integer => quote!(Integer),
+            ApplicationCommandOptionType::Boolean => quote!(Boolean),
+            ApplicationCommandOptionType::User => quote!(User),
+            ApplicationCommandOptionType::Channel => quote!(Channel),
+            ApplicationCommandOptionType::Role => quote!(Role),
+            ApplicationCommandOptionType::Mentionable => quote!(Mentionable),
+            ApplicationCommandOptionType::Number => quote!(Number),
+            ApplicationCommandOptionType::Unknown => quote!(Unknown),
+        };
+
+        stream.extend(quote! {
+            #path::#variant
+        });
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Arg {
+    pub name: String,
+    pub description: String,
+    pub kind: ApplicationCommandOptionType,
+    pub required: bool,
+}
+
+impl Default for Arg {
+    fn default() -> Self {
+        Self {
+            name: String::new(),
+            description: String::new(),
+            kind: ApplicationCommandOptionType::String,
+            required: false,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Subcommand {
+    pub name: String,
+    pub description: String,
+    pub cmd_args: Vec<Arg>,
+}
+
+impl Default for Subcommand {
+    fn default() -> Self {
+        Self { name: String::new(), description: String::new(), cmd_args: vec![] }
+    }
+}
+
+impl Subcommand {
+    pub(crate) fn new(name: String) -> Self {
+        Self { name, ..Default::default() }
+    }
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct Options {
+    pub aliases: Vec<String>,
+    pub description: String,
+    pub group: String,
+    pub examples: Vec<String>,
+    pub required_permissions: PermissionLevel,
+    pub can_blacklist: bool,
+    pub supports_dm: bool,
+    pub cmd_args: Vec<Arg>,
+    pub subcommands: Vec<Subcommand>,
+}
+
+impl Options {
+    #[inline]
+    pub fn new() -> Self {
+        Self { group: "None".to_string(), ..Default::default() }
+    }
+}

command_attributes/src/util.rs

@@ -0,0 +1,176 @@
+use proc_macro::TokenStream;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::{format_ident, quote, ToTokens};
+use syn::{
+    braced, bracketed, parenthesized,
+    parse::{Error, Parse, ParseStream, Result as SynResult},
+    punctuated::Punctuated,
+    token::{Comma, Mut},
+    Ident, Lifetime, Lit, Type,
+};
+
+pub trait LitExt {
+    fn to_str(&self) -> String;
+    fn to_bool(&self) -> bool;
+    fn to_ident(&self) -> Ident;
+}
+
+impl LitExt for Lit {
+    fn to_str(&self) -> String {
+        match self {
+            Lit::Str(s) => s.value(),
+            Lit::ByteStr(s) => unsafe { String::from_utf8_unchecked(s.value()) },
+            Lit::Char(c) => c.value().to_string(),
+            Lit::Byte(b) => (b.value() as char).to_string(),
+            _ => panic!("values must be a (byte)string or a char"),
+        }
+    }
+
+    fn to_bool(&self) -> bool {
+        if let Lit::Bool(b) = self {
+            b.value
+        } else {
+            self.to_str()
+                .parse()
+                .unwrap_or_else(|_| panic!("expected bool from {:?}", self))
+        }
+    }
+
+    #[inline]
+    fn to_ident(&self) -> Ident {
+        Ident::new(&self.to_str(), self.span())
+    }
+}
+
+pub trait IdentExt2: Sized {
+    fn to_uppercase(&self) -> Self;
+    fn with_suffix(&self, suf: &str) -> Ident;
+}
+
+impl IdentExt2 for Ident {
+    #[inline]
+    fn to_uppercase(&self) -> Self {
+        format_ident!("{}", self.to_string().to_uppercase())
+    }
+
+    #[inline]
+    fn with_suffix(&self, suffix: &str) -> Ident {
+        format_ident!("{}_{}", self.to_string().to_uppercase(), suffix)
+    }
+}
+
+#[inline]
+pub fn into_stream(e: Error) -> TokenStream {
+    e.to_compile_error().into()
+}
+
+macro_rules! propagate_err {
+    ($res:expr) => {{
+        match $res {
+            Ok(v) => v,
+            Err(e) => return $crate::util::into_stream(e),
+        }
+    }};
+}
+
+#[derive(Debug)]
+pub struct Bracketed<T>(pub Punctuated<T, Comma>);
+
+impl<T: Parse> Parse for Bracketed<T> {
+    fn parse(input: ParseStream<'_>) -> SynResult<Self> {
+        let content;
+        bracketed!(content in input);
+
+        Ok(Bracketed(content.parse_terminated(T::parse)?))
+    }
+}
+
+#[derive(Debug)]
+pub struct Braced<T>(pub Punctuated<T, Comma>);
+
+impl<T: Parse> Parse for Braced<T> {
+    fn parse(input: ParseStream<'_>) -> SynResult<Self> {
+        let content;
+        braced!(content in input);
+
+        Ok(Braced(content.parse_terminated(T::parse)?))
+    }
+}
+
+#[derive(Debug)]
+pub struct Parenthesised<T>(pub Punctuated<T, Comma>);
+
+impl<T: Parse> Parse for Parenthesised<T> {
+    fn parse(input: ParseStream<'_>) -> SynResult<Self> {
+        let content;
+        parenthesized!(content in input);
+
+        Ok(Parenthesised(content.parse_terminated(T::parse)?))
+    }
+}
+
+#[derive(Debug)]
+pub struct AsOption<T>(pub Option<T>);
+
+impl<T: ToTokens> ToTokens for AsOption<T> {
+    fn to_tokens(&self, stream: &mut TokenStream2) {
+        match &self.0 {
+            Some(o) => stream.extend(quote!(Some(#o))),
+            None => stream.extend(quote!(None)),
+        }
+    }
+}
+
+impl<T> Default for AsOption<T> {
+    #[inline]
+    fn default() -> Self {
+        AsOption(None)
+    }
+}
+
+#[derive(Debug)]
+pub struct Argument {
+    pub mutable: Option<Mut>,
+    pub name: Ident,
+    pub kind: Type,
+}
+
+impl ToTokens for Argument {
+    fn to_tokens(&self, stream: &mut TokenStream2) {
+        let Argument {
+            mutable,
+            name,
+            kind,
+        } = self;
+
+        stream.extend(quote! {
+            #mutable #name: #kind
+        });
+    }
+}
+
+#[inline]
+pub fn populate_fut_lifetimes_on_refs(args: &mut Vec<Argument>) {
+    for arg in args {
+        if let Type::Reference(reference) = &mut arg.kind {
+            reference.lifetime = Some(Lifetime::new("'fut", Span::call_site()));
+        }
+    }
+}
+
+pub fn append_line(desc: &mut String, mut line: String) {
+    if line.starts_with(' ') {
+        line.remove(0);
+    }
+
+    match line.rfind("\\$") {
+        Some(i) => {
+            desc.push_str(line[..i].trim_end());
+            desc.push(' ');
+        }
+        None => {
+            desc.push_str(&line);
+            desc.push('\n');
+        }
+    }
+}