-#![recursion_limit="256"]
+#![recursion_limit = "256"]
extern crate proc_macro;
use darling::*;
use proc_macro::TokenStream;
-use proc_macro2::{TokenStream as SynTokenStream, Literal};
-use std::collections::HashSet;
-use syn::{*, Result, Error};
-use syn::export::Span;
-use syn::spanned::Spanned;
+use proc_macro2::{Literal, Span, TokenStream as SynTokenStream};
use quote::*;
+use std::{collections::HashSet, fmt::Display};
+use syn::spanned::Spanned;
+use syn::{Error, Result, *};
/// Helper function for emitting compile errors.
-fn error<T>(span: Span, message: &str) -> Result<T> {
+fn error<T>(span: Span, message: impl Display) -> Result<T> {
Err(Error::new(span, message))
}
#[darling(attributes(enumset), default)]
struct EnumsetAttrs {
no_ops: bool,
+ no_super_impls: bool,
+ #[darling(default)]
+ repr: Option<String>,
serialize_as_list: bool,
+ serialize_as_map: bool,
serialize_deny_unknown: bool,
#[darling(default)]
serialize_repr: Option<String>,
+ #[darling(default)]
+ crate_name: Option<String>,
}
/// An variant in the enum set type.
struct EnumSetValue {
+ /// The name of the variant.
name: Ident,
+ /// The discriminant of the variant.
variant_repr: u32,
}
/// Stores information about the enum set type.
#[allow(dead_code)]
struct EnumSetInfo {
+ /// The name of the enum.
name: Ident,
+ /// The crate name to use.
+ crate_name: Option<Ident>,
+ /// The numeric type to represent the `EnumSet` as in memory.
+ explicit_mem_repr: Option<Ident>,
+ /// The numeric type to serialize the enum as.
explicit_serde_repr: Option<Ident>,
+ /// Whether the underlying repr of the enum supports negative values.
has_signed_repr: bool,
+ /// Whether the underlying repr of the enum supports values higher than 2^32.
has_large_repr: bool,
+ /// A list of variants in the enum.
variants: Vec<EnumSetValue>,
+ /// The highest encountered variant discriminant.
max_discrim: u32,
+ /// The current variant discriminant. Used to track, e.g. `A=10,B,C`.
cur_discrim: u32,
+ /// A list of variant names that are already in use.
used_variant_names: HashSet<String>,
- used_discriminators: HashSet<u32>,
+ /// A list of variant discriminants that are already in use.
+ used_discriminants: HashSet<u32>,
+ /// Avoid generating operator overloads on the enum type.
no_ops: bool,
+ /// Avoid generating implementations for `Clone`, `Copy`, `Eq`, and `PartialEq`.
+ no_super_impls: bool,
+ /// Serialize the enum as a list.
serialize_as_list: bool,
+ /// Serialize the enum as a map.
+ serialize_as_map: bool,
+ /// Disallow unknown bits while deserializing the enum.
serialize_deny_unknown: bool,
}
impl EnumSetInfo {
fn new(input: &DeriveInput, attrs: EnumsetAttrs) -> EnumSetInfo {
EnumSetInfo {
name: input.ident.clone(),
- explicit_serde_repr: attrs.serialize_repr.map(|x| Ident::new(&x, Span::call_site())),
+ crate_name: attrs.crate_name.map(|x| Ident::new(&x, Span::call_site())),
+ explicit_mem_repr: attrs.repr.map(|x| Ident::new(&x, Span::call_site())),
+ explicit_serde_repr: attrs
+ .serialize_repr
+ .map(|x| Ident::new(&x, Span::call_site())),
has_signed_repr: false,
has_large_repr: false,
variants: Vec::new(),
max_discrim: 0,
cur_discrim: 0,
used_variant_names: HashSet::new(),
- used_discriminators: HashSet::new(),
+ used_discriminants: HashSet::new(),
no_ops: attrs.no_ops,
+ no_super_impls: attrs.no_super_impls,
serialize_as_list: attrs.serialize_as_list,
- serialize_deny_unknown: attrs.serialize_deny_unknown
+ serialize_as_map: attrs.serialize_as_map,
+ serialize_deny_unknown: attrs.serialize_deny_unknown,
}
}
+ /// Sets an explicit repr for the enumset.
fn push_explicit_repr(&mut self, attr_span: Span, repr: &str) -> Result<()> {
+ // Check whether the repr is supported, and if so, set some flags for better error
+ // messages later on.
match repr {
"Rust" | "C" | "u8" | "u16" | "u32" => Ok(()),
"usize" | "u64" | "u128" => {
self.has_large_repr = true;
Ok(())
}
- _ => error(attr_span, "Unsupported repr.")
+ _ => error(attr_span, "Unsupported repr."),
}
}
+ /// Adds a variant to the enumset.
fn push_variant(&mut self, variant: &Variant) -> Result<()> {
if self.used_variant_names.contains(&variant.ident.to_string()) {
error(variant.span(), "Duplicated variant name.")
} else if let Fields::Unit = variant.fields {
+ // Parse the discriminant.
if let Some((_, expr)) = &variant.discriminant {
let discriminant_fail_message = format!(
"Enum set discriminants must be `u32`s.{}",
}
}
+ // Validate the discriminant.
let discriminant = self.cur_discrim;
if discriminant >= 128 {
let message = if self.variants.len() <= 127 {
};
error(variant.span(), message)?;
}
-
- if self.used_discriminators.contains(&discriminant) {
+ if self.used_discriminants.contains(&discriminant) {
error(variant.span(), "Duplicated enum discriminant.")?;
}
+ // Add the variant to the info.
self.cur_discrim += 1;
if discriminant > self.max_discrim {
self.max_discrim = discriminant;
}
- self.variants.push(EnumSetValue {
- name: variant.ident.clone(),
- variant_repr: discriminant,
- });
+ self.variants
+ .push(EnumSetValue { name: variant.ident.clone(), variant_repr: discriminant });
self.used_variant_names.insert(variant.ident.to_string());
- self.used_discriminators.insert(discriminant);
+ self.used_discriminants.insert(discriminant);
Ok(())
} else {
error(variant.span(), "`#[derive(EnumSetType)]` can only be used on fieldless enums.")
}
}
+ /// Validate the enumset type.
fn validate(&self) -> Result<()> {
- if let Some(explicit_serde_repr) = &self.explicit_serde_repr {
- let is_overflowed = match explicit_serde_repr.to_string().as_str() {
- "u8" => self.max_discrim >= 8,
- "u16" => self.max_discrim >= 16,
- "u32" => self.max_discrim >= 32,
- "u64" => self.max_discrim >= 64,
- "u128" => self.max_discrim >= 128,
+ fn do_check(ty: &str, max_discrim: u32, what: &str) -> Result<()> {
+ let is_overflowed = match ty {
+ "u8" => max_discrim >= 8,
+ "u16" => max_discrim >= 16,
+ "u32" => max_discrim >= 32,
+ "u64" => max_discrim >= 64,
+ "u128" => max_discrim >= 128,
_ => error(
Span::call_site(),
- "Only `u8`, `u16`, `u32`, `u64` and `u128` are supported for serde_repr."
+ format!(
+ "Only `u8`, `u16`, `u32`, `u64` and `u128` are supported for {}.",
+ what
+ ),
)?,
};
if is_overflowed {
- error(Span::call_site(), "serialize_repr cannot be smaller than bitset.")?;
+ error(Span::call_site(), format!("{} cannot be smaller than bitset.", what))?;
}
+ Ok(())
+ }
+
+ // Check if all bits of the bitset can fit in the serialization representation.
+ if let Some(explicit_serde_repr) = &self.explicit_serde_repr {
+ do_check(&explicit_serde_repr.to_string(), self.max_discrim, "serialize_repr")?;
+ }
+
+ // Check if all bits of the bitset can fit in the memory representation, if one was given.
+ if let Some(explicit_mem_repr) = &self.explicit_mem_repr {
+ do_check(&explicit_mem_repr.to_string(), self.max_discrim, "repr")?;
}
Ok(())
}
+ /// Computes the underlying type used to store the enumset.
fn enumset_repr(&self) -> SynTokenStream {
- if self.max_discrim <= 7 {
+ if let Some(explicit_mem_repr) = &self.explicit_mem_repr {
+ explicit_mem_repr.to_token_stream()
+ } else if self.max_discrim <= 7 {
quote! { u8 }
} else if self.max_discrim <= 15 {
quote! { u16 }
panic!("max_variant > 127?")
}
}
+ /// Computes the underlying type used to serialize the enumset.
#[cfg(feature = "serde")]
fn serde_repr(&self) -> SynTokenStream {
if let Some(serde_repr) = &self.explicit_serde_repr {
}
}
+ /// Returns a bitmask of all variants in the set.
fn all_variants(&self) -> u128 {
let mut accum = 0u128;
for variant in &self.variants {
}
}
+/// Generates the actual `EnumSetType` impl.
fn enum_set_type_impl(info: EnumSetInfo) -> SynTokenStream {
let name = &info.name;
- let typed_enumset = quote!(::enumset::EnumSet<#name>);
- let core = quote!(::enumset::__internal::core_export);
+
+ let enumset = match &info.crate_name {
+ Some(crate_name) => quote!(::#crate_name),
+ None => {
+ #[cfg(feature = "proc-macro-crate")]
+ {
+ use proc_macro_crate::FoundCrate;
+
+ let crate_name = proc_macro_crate::crate_name("enumset");
+ match crate_name {
+ Ok(FoundCrate::Name(name)) => {
+ let ident = Ident::new(&name, Span::call_site());
+ quote!(::#ident)
+ }
+ _ => quote!(::enumset),
+ }
+ }
+
+ #[cfg(not(feature = "proc-macro-crate"))]
+ {
+ quote!(::enumset)
+ }
+ }
+ };
+ let typed_enumset = quote!(#enumset::EnumSet<#name>);
+ let core = quote!(#enumset::__internal::core_export);
let repr = info.enumset_repr();
let all_variants = Literal::u128_unsuffixed(info.all_variants());
impl <O : Into<#typed_enumset>> #core::ops::Sub<O> for #name {
type Output = #typed_enumset;
fn sub(self, other: O) -> Self::Output {
- ::enumset::EnumSet::only(self) - other.into()
+ #enumset::EnumSet::only(self) - other.into()
}
}
impl <O : Into<#typed_enumset>> #core::ops::BitAnd<O> for #name {
type Output = #typed_enumset;
fn bitand(self, other: O) -> Self::Output {
- ::enumset::EnumSet::only(self) & other.into()
+ #enumset::EnumSet::only(self) & other.into()
}
}
impl <O : Into<#typed_enumset>> #core::ops::BitOr<O> for #name {
type Output = #typed_enumset;
fn bitor(self, other: O) -> Self::Output {
- ::enumset::EnumSet::only(self) | other.into()
+ #enumset::EnumSet::only(self) | other.into()
}
}
impl <O : Into<#typed_enumset>> #core::ops::BitXor<O> for #name {
type Output = #typed_enumset;
fn bitxor(self, other: O) -> Self::Output {
- ::enumset::EnumSet::only(self) ^ other.into()
+ #enumset::EnumSet::only(self) ^ other.into()
}
}
impl #core::ops::Not for #name {
type Output = #typed_enumset;
fn not(self) -> Self::Output {
- !::enumset::EnumSet::only(self)
+ !#enumset::EnumSet::only(self)
}
}
impl #core::cmp::PartialEq<#typed_enumset> for #name {
fn eq(&self, other: &#typed_enumset) -> bool {
- ::enumset::EnumSet::only(*self) == *other
+ #enumset::EnumSet::only(*self) == *other
}
}
}
};
-
#[cfg(feature = "serde")]
- let serde = quote!(::enumset::__internal::serde);
+ let serde = quote!(#enumset::__internal::serde);
#[cfg(feature = "serde")]
let serde_ops = if info.serialize_as_list {
let expecting_str = format!("a list of {}", name);
quote! {
fn serialize<S: #serde::Serializer>(
- set: ::enumset::EnumSet<#name>, ser: S,
+ set: #enumset::EnumSet<#name>, ser: S,
) -> #core::result::Result<S::Ok, S::Error> {
use #serde::ser::SerializeSeq;
let mut seq = ser.serialize_seq(#core::prelude::v1::Some(set.len()))?;
}
fn deserialize<'de, D: #serde::Deserializer<'de>>(
de: D,
- ) -> #core::result::Result<::enumset::EnumSet<#name>, D::Error> {
+ ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
struct Visitor;
impl <'de> #serde::de::Visitor<'de> for Visitor {
- type Value = ::enumset::EnumSet<#name>;
+ type Value = #enumset::EnumSet<#name>;
fn expecting(
&self, formatter: &mut #core::fmt::Formatter,
) -> #core::fmt::Result {
) -> #core::result::Result<Self::Value, A::Error> where
A: #serde::de::SeqAccess<'de>
{
- let mut accum = ::enumset::EnumSet::<#name>::new();
+ let mut accum = #enumset::EnumSet::<#name>::new();
while let #core::prelude::v1::Some(val) = seq.next_element::<#name>()? {
accum |= val;
}
de.deserialize_seq(Visitor)
}
}
+ } else if info.serialize_as_map {
+ let expecting_str = format!("a map from {} to bool", name);
+ quote! {
+ fn serialize<S: #serde::Serializer>(
+ set: #enumset::EnumSet<#name>, ser: S,
+ ) -> #core::result::Result<S::Ok, S::Error> {
+ use #serde::ser::SerializeMap;
+ let mut map = ser.serialize_map(#core::prelude::v1::Some(set.len()))?;
+ for bit in set {
+ map.serialize_entry(&bit, &true)?;
+ }
+ map.end()
+ }
+ fn deserialize<'de, D: #serde::Deserializer<'de>>(
+ de: D,
+ ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
+ struct Visitor;
+ impl <'de> #serde::de::Visitor<'de> for Visitor {
+ type Value = #enumset::EnumSet<#name>;
+ fn expecting(
+ &self, formatter: &mut #core::fmt::Formatter,
+ ) -> #core::fmt::Result {
+ write!(formatter, #expecting_str)
+ }
+ fn visit_map<A>(
+ mut self, mut map: A,
+ ) -> #core::result::Result<Self::Value, A::Error> where
+ A: #serde::de::MapAccess<'de>
+ {
+ let mut accum = #enumset::EnumSet::<#name>::new();
+ while let #core::prelude::v1::Some((val, true)) = map.next_entry::<#name, bool>()? {
+ accum |= val;
+ }
+ #core::prelude::v1::Ok(accum)
+ }
+ }
+ de.deserialize_map(Visitor)
+ }
+ }
} else {
let serialize_repr = info.serde_repr();
let check_unknown = if info.serialize_deny_unknown {
}
}
} else {
- quote! { }
+ quote! {}
};
quote! {
fn serialize<S: #serde::Serializer>(
- set: ::enumset::EnumSet<#name>, ser: S,
+ set: #enumset::EnumSet<#name>, ser: S,
) -> #core::result::Result<S::Ok, S::Error> {
- #serde::Serialize::serialize(&(set.__enumset_underlying as #serialize_repr), ser)
+ #serde::Serialize::serialize(&(set.__priv_repr as #serialize_repr), ser)
}
fn deserialize<'de, D: #serde::Deserializer<'de>>(
de: D,
- ) -> #core::result::Result<::enumset::EnumSet<#name>, D::Error> {
+ ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
let value = <#serialize_repr as #serde::Deserialize>::deserialize(de)?;
#check_unknown
- #core::prelude::v1::Ok(::enumset::EnumSet {
- __enumset_underlying: (value & #all_variants) as #repr,
+ #core::prelude::v1::Ok(#enumset::EnumSet {
+ __priv_repr: (value & #all_variants) as #repr,
})
}
}
};
#[cfg(not(feature = "serde"))]
- let serde_ops = quote! { };
+ let serde_ops = quote! {};
let is_uninhabited = info.variants.is_empty();
let is_zst = info.variants.len() == 1;
let variant_value: Vec<_> = info.variants.iter().map(|x| x.variant_repr).collect();
let const_field: Vec<_> = ["IS_U8", "IS_U16", "IS_U32", "IS_U64", "IS_U128"]
- .iter().map(|x| Ident::new(x, Span::call_site())).collect();
+ .iter()
+ .map(|x| Ident::new(x, Span::call_site()))
+ .collect();
let int_type: Vec<_> = ["u8", "u16", "u32", "u64", "u128"]
- .iter().map(|x| Ident::new(x, Span::call_site())).collect();
+ .iter()
+ .map(|x| Ident::new(x, Span::call_site()))
+ .collect();
quote! {
fn enum_into_u32(self) -> u32 {
self as u32
}
unsafe fn enum_from_u32(val: u32) -> Self {
- // We put these in const fields so they aren't generated even on -O0
+ // We put these in const fields so the branches they guard aren't generated even
+ // on -O0
#(const #const_field: bool =
#core::mem::size_of::<#name>() == #core::mem::size_of::<#int_type>();)*
match val {
quote!((*self as u32) == (*other as u32))
};
+ // used in the enum_set! macro `const fn`s.
+ let self_as_repr_mask = if is_uninhabited {
+ quote! { 0 } // impossible anyway
+ } else {
+ quote! { 1 << self as #repr }
+ };
+
+ let super_impls = if info.no_super_impls {
+ quote! {}
+ } else {
+ quote! {
+ impl #core::cmp::PartialEq for #name {
+ fn eq(&self, other: &Self) -> bool {
+ #eq_impl
+ }
+ }
+ impl #core::cmp::Eq for #name { }
+ #[allow(clippy::expl_impl_clone_on_copy)]
+ impl #core::clone::Clone for #name {
+ fn clone(&self) -> Self {
+ *self
+ }
+ }
+ impl #core::marker::Copy for #name { }
+ }
+ };
+
+ let impl_with_repr = if info.explicit_mem_repr.is_some() {
+ quote! {
+ unsafe impl #enumset::EnumSetTypeWithRepr for #name {
+ type Repr = #repr;
+ }
+ }
+ } else {
+ quote! {}
+ };
+
quote! {
- unsafe impl ::enumset::__internal::EnumSetTypePrivate for #name {
+ unsafe impl #enumset::__internal::EnumSetTypePrivate for #name {
type Repr = #repr;
const ALL_BITS: Self::Repr = #all_variants;
#into_impl
#serde_ops
}
- unsafe impl ::enumset::EnumSetType for #name { }
+ unsafe impl #enumset::EnumSetType for #name { }
+
+ #impl_with_repr
+ #super_impls
- impl #core::cmp::PartialEq for #name {
- fn eq(&self, other: &Self) -> bool {
- #eq_impl
+ impl #name {
+ /// Creates a new enumset with only this variant.
+ #[deprecated(note = "This method is an internal implementation detail generated by \
+ the `enumset` crate's procedural macro. It should not be used \
+ directly. Use `EnumSet::only` instead.")]
+ #[doc(hidden)]
+ pub const fn __impl_enumset_internal__const_only(self) -> #enumset::EnumSet<#name> {
+ #enumset::EnumSet { __priv_repr: #self_as_repr_mask }
}
- }
- impl #core::cmp::Eq for #name { }
- impl #core::clone::Clone for #name {
- fn clone(&self) -> Self {
- *self
+
+ /// Creates a new enumset with this variant added.
+ #[deprecated(note = "This method is an internal implementation detail generated by \
+ the `enumset` crate's procedural macro. It should not be used \
+ directly. Use the `|` operator instead.")]
+ #[doc(hidden)]
+ pub const fn __impl_enumset_internal__const_merge(
+ self, chain: #enumset::EnumSet<#name>,
+ ) -> #enumset::EnumSet<#name> {
+ #enumset::EnumSet { __priv_repr: chain.__priv_repr | #self_as_repr_mask }
}
}
- impl #core::marker::Copy for #name { }
#ops
}
}
-fn derive_enum_set_type_impl(input: DeriveInput, attrs: EnumsetAttrs) -> Result<TokenStream> {
+#[proc_macro_derive(EnumSetType, attributes(enumset))]
+pub fn derive_enum_set_type(input: TokenStream) -> TokenStream {
+ let input: DeriveInput = parse_macro_input!(input);
+ let attrs: EnumsetAttrs = match EnumsetAttrs::from_derive_input(&input) {
+ Ok(attrs) => attrs,
+ Err(e) => return e.write_errors().into(),
+ };
+ match derive_enum_set_type_0(input, attrs) {
+ Ok(v) => v,
+ Err(e) => e.to_compile_error().into(),
+ }
+}
+fn derive_enum_set_type_0(input: DeriveInput, attrs: EnumsetAttrs) -> Result<TokenStream> {
if !input.generics.params.is_empty() {
error(
input.generics.span(),
error(input.span(), "`#[derive(EnumSetType)]` may only be used on enums")
}
}
-
-#[proc_macro_derive(EnumSetType, attributes(enumset))]
-pub fn derive_enum_set_type(input: TokenStream) -> TokenStream {
- let input: DeriveInput = parse_macro_input!(input);
- let attrs: EnumsetAttrs = match EnumsetAttrs::from_derive_input(&input) {
- Ok(attrs) => attrs,
- Err(e) => return e.write_errors().into(),
- };
- match derive_enum_set_type_impl(input, attrs) {
- Ok(v) => v,
- Err(e) => e.to_compile_error().into(),
- }
-}
\ No newline at end of file
projects / enumset.git / blobdiff