diff options
Diffstat (limited to 'third_party/rust/enum-primitive-derive/src')
| -rw-r--r-- | third_party/rust/enum-primitive-derive/src/lib.rs | 278 |
1 files changed, 278 insertions, 0 deletions
diff --git a/third_party/rust/enum-primitive-derive/src/lib.rs b/third_party/rust/enum-primitive-derive/src/lib.rs new file mode 100644 index 0000000000..135f6164c7 --- /dev/null +++ b/third_party/rust/enum-primitive-derive/src/lib.rs @@ -0,0 +1,278 @@ +// Copyright (c) 2017 Doug Goldstein <cardoe@cardoe.com> + +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// “Software”), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: + +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +//! This crate provides a custom derive `Primitive` that helps people +//! providing native Rust bindings to C code by allowing a C-like `enum` +//! declaration to convert to its primitve values and back from them. You +//! can selectively include `num_traits::ToPrimitive` and +//! `num_traits::FromPrimitive` to get these features. +//! +//! # Example +//! +//! ```rust +//! use enum_primitive_derive::Primitive; +//! use num_traits::{FromPrimitive, ToPrimitive}; +//! +//! #[derive(Debug, Eq, PartialEq, Primitive)] +//! enum Foo { +//! Bar = 32, +//! Dead = 42, +//! Beef = 50, +//! } +//! +//! fn main() { +//! assert_eq!(Foo::from_i32(32), Some(Foo::Bar)); +//! assert_eq!(Foo::from_i32(42), Some(Foo::Dead)); +//! assert_eq!(Foo::from_i64(50), Some(Foo::Beef)); +//! assert_eq!(Foo::from_isize(17), None); +//! +//! let bar = Foo::Bar; +//! assert_eq!(bar.to_i32(), Some(32)); +//! +//! let dead = Foo::Dead; +//! assert_eq!(dead.to_isize(), Some(42)); +//! } +//! ``` +//! +//! # Complex Example +//! +//! ```rust +//! use enum_primitive_derive::Primitive; +//! use num_traits::{FromPrimitive, ToPrimitive}; +//! +//! pub const ABC: ::std::os::raw::c_uint = 1; +//! pub const DEF: ::std::os::raw::c_uint = 2; +//! pub const GHI: ::std::os::raw::c_uint = 4; +//! +//! #[derive(Clone, Copy, Debug, Eq, PartialEq, Primitive)] +//! enum BindGenLike { +//! ABC = ABC as isize, +//! DEF = DEF as isize, +//! GHI = GHI as isize, +//! } +//! +//! fn main() { +//! assert_eq!(BindGenLike::from_isize(4), Some(BindGenLike::GHI)); +//! assert_eq!(BindGenLike::from_u32(2), Some(BindGenLike::DEF)); +//! assert_eq!(BindGenLike::from_u32(8), None); +//! +//! let abc = BindGenLike::ABC; +//! assert_eq!(abc.to_u32(), Some(1)); +//! } +//! ``` +//! +//! # TryFrom Example +//! +//! ```rust +//! use enum_primitive_derive::Primitive; +//! use core::convert::TryFrom; +//! +//! #[derive(Debug, Eq, PartialEq, Primitive)] +//! enum Foo { +//! Bar = 32, +//! Dead = 42, +//! Beef = 50, +//! } +//! +//! fn main() { +//! let bar = Foo::try_from(32); +//! assert_eq!(bar, Ok(Foo::Bar)); +//! +//! let dead = Foo::try_from(42); +//! assert_eq!(dead, Ok(Foo::Dead)); +//! +//! let unknown = Foo::try_from(12); +//! assert!(unknown.is_err()); +//! } +//! ``` + +extern crate proc_macro; + +use proc_macro::TokenStream; + +/// Provides implementation of `num_traits::ToPrimitive` and +/// `num_traits::FromPrimitive` +#[proc_macro_derive(Primitive)] +pub fn primitive(input: TokenStream) -> TokenStream { + let ast = syn::parse_macro_input!(input as syn::DeriveInput); + impl_primitive(&ast) +} + +fn impl_primitive(ast: &syn::DeriveInput) -> TokenStream { + let name = &ast.ident; + + // Check if derive(Primitive) was specified for a struct + if let syn::Data::Enum(ref variant) = ast.data { + let (var_u64, dis_u64): (Vec<_>, Vec<_>) = variant + .variants + .iter() + .map(|v| { + match v.fields { + syn::Fields::Unit => (), + _ => panic!("#[derive(Primitive) can only operate on C-like enums"), + } + if v.discriminant.is_none() { + panic!( + "#[derive(Primitive) requires C-like enums with \ + discriminants for all enum variants" + ); + } + + let discrim = match v.discriminant.clone().map(|(_eq, expr)| expr).unwrap() { + syn::Expr::Cast(real) => *real.expr, + orig => orig, + }; + (v.ident.clone(), discrim) + }) + .unzip(); + + // quote!{} needs this to be a vec since its in #( )* + let enum_u64 = vec![name.clone(); variant.variants.len()]; + + // can't reuse variables in quote!{} body + let var_i64 = var_u64.clone(); + let dis_i64 = dis_u64.clone(); + let enum_i64 = enum_u64.clone(); + + let to_name = name.clone(); + let to_enum_u64 = enum_u64.clone(); + let to_var_u64 = var_u64.clone(); + let to_dis_u64 = dis_u64.clone(); + + let to_enum_i64 = enum_u64.clone(); + let to_var_i64 = var_u64.clone(); + let to_dis_i64 = dis_u64.clone(); + + TokenStream::from(quote::quote! { + impl ::num_traits::FromPrimitive for #name { + fn from_u64(val: u64) -> Option<Self> { + match val as _ { + #( #dis_u64 => Some(#enum_u64::#var_u64), )* + _ => None, + } + } + + fn from_i64(val: i64) -> Option<Self> { + match val as _ { + #( #dis_i64 => Some(#enum_i64::#var_i64), )* + _ => None, + } + } + } + + impl ::num_traits::ToPrimitive for #to_name { + fn to_u64(&self) -> Option<u64> { + match *self { + #( #to_enum_u64::#to_var_u64 => Some(#to_dis_u64 as u64), )* + } + } + + fn to_i64(&self) -> Option<i64> { + match *self { + #( #to_enum_i64::#to_var_i64 => Some(#to_dis_i64 as i64), )* + } + } + } + + impl ::core::convert::TryFrom<u64> for #to_name { + type Error = &'static str; + + fn try_from(value: u64) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_u64(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<u32> for #to_name { + type Error = &'static str; + + fn try_from(value: u32) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_u32(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<u16> for #to_name { + type Error = &'static str; + + fn try_from(value: u16) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_u16(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<u8> for #to_name { + type Error = &'static str; + + fn try_from(value: u8) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_u8(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<i64> for #name { + type Error = &'static str; + + fn try_from(value: i64) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_i64(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<i32> for #name { + type Error = &'static str; + + fn try_from(value: i32) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_i32(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<i16> for #name { + type Error = &'static str; + + fn try_from(value: i16) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_i16(value).ok_or_else(|| "Unknown variant") + } + } + + impl ::core::convert::TryFrom<i8> for #name { + type Error = &'static str; + + fn try_from(value: i8) -> ::core::result::Result<Self, Self::Error> { + use ::num_traits::FromPrimitive; + + #to_name::from_i8(value).ok_or_else(|| "Unknown variant") + } + } + }) + } else { + panic!("#[derive(Primitive)] is only valid for C-like enums"); + } +} |