third_party/rust_crates/vendor/enum-as-inner/src/lib.rs - fuchsia - Git at Google

 // Copyright 2015-2018 Benjamin Fry <benjaminfry@me.com>
 //
 // Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.

 //! # enum-as-inner
 //!
 //! A deriving proc-macro for generating functions to automatically give access to the inner members of enum.
 //!
 //! ## Basic unnamed field case
 //!
 //! The basic case is meant for single item enums, like:
 //!
 //! ```rust
 //! # #[macro_use] extern crate enum_as_inner;
 //! # fn main() {
 //!
 //! #[derive(Debug, EnumAsInner)]
 //! enum OneEnum {
 //!     One(u32),
 //! }
 //!
 //! let one = OneEnum::One(1);
 //!
 //! assert_eq!(*one.as_one().unwrap(), 1);
 //! assert_eq!(one.into_one().unwrap(), 1);
 //! # }
 //! ```
 //!
 //! where the result is either a reference for inner items or a tuple containing the inner items.
 //!
 //! ## Unit case
 //!
 //! This will return copy's of the value of the unit variant, as `isize`:
 //!
 //! ```rust
 //! # #[macro_use] extern crate enum_as_inner;
 //! # fn main() {
 //!
 //! #[derive(EnumAsInner)]
 //! enum UnitVariants {
 //!     Zero,
 //!     One,
 //!     Two,
 //! }
 //!
 //! let unit = UnitVariants::Two;
 //!
 //! assert_eq!(unit.as_two().unwrap(), ());
 //! # }
 //! ```
 //!
 //! Note that for unit enums there is no `into_*()` function generated.
 //!
 //! ## Mutliple, unnamed field case
 //!
 //! This will return a tuple of the inner types:
 //!
 //! ```rust
 //! # #[macro_use] extern crate enum_as_inner;
 //! # fn main() {
 //!
 //! #[derive(Debug, EnumAsInner)]
 //! enum ManyVariants {
 //!     One(u32),
 //!     Two(u32, i32),
 //!     Three(bool, u32, i64),
 //! }
 //!
 //! let many = ManyVariants::Three(true, 1, 2);
 //!
 //! assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
 //! assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));
 //! # }
 //! ```
 //!
 //! ## Multiple, named field case
 //!
 //! This will return a tuple of the inner types, like the unnamed option:
 //!
 //! ```rust
 //! # #[macro_use] extern crate enum_as_inner;
 //! # fn main() {
 //!
 //! #[derive(Debug, EnumAsInner)]
 //! enum ManyVariants {
 //!     One { one: u32 },
 //!     Two { one: u32, two: i32 },
 //!     Three { one: bool, two: u32, three: i64 },
 //! }
 //!
 //! let many = ManyVariants::Three { one: true, two: 1, three: 2 };
 //!
 //! assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
 //! assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));
 //! # }
 //! ```

 extern crate proc_macro;
 extern crate proc_macro2;
 #[macro_use]
 extern crate syn;
 #[macro_use]
 extern crate quote;

 use heck::SnakeCase;
 use proc_macro2::{Ident, Span, TokenStream};
 use syn::DeriveInput;

 /// returns first the types to return, the match names, and then tokens to the field accesses
 fn unit_fields_return(
     name: &syn::Ident,
     variant_name: &syn::Ident,
     function_name: &Ident,
     doc: &str,
 ) -> TokenStream {
     quote!(
         #[doc = #doc ]
         pub fn #function_name(&self) -> Option<()> {
             match self {
                 #name::#variant_name => {
                     Some(())
                 }
                 _ => None
             }
         }
     )
 }

 /// returns first the types to return, the match names, and then tokens to the field accesses
 fn unnamed_fields_return(
     name: &syn::Ident,
     variant_name: &syn::Ident,
     (function_name_ref, doc_ref): (&Ident, &str),
     (function_name_val, doc_val): (&Ident, &str),
     fields: &syn::FieldsUnnamed,
 ) -> TokenStream {
     let (returns_ref, returns_val, matches, accesses_ref, accesses_val) = match fields.unnamed.len()
     {
         1 => {
             let field = fields.unnamed.first().expect("no fields on type");

             let returns = &field.ty;
             let returns_ref = quote!(&#returns);
             let returns_val = quote!(#returns);
             let matches = quote!(inner);
             let accesses_ref = quote!(&inner);
             let accesses_val = quote!(inner);

             (
                 returns_ref,
                 returns_val,
                 matches,
                 accesses_ref,
                 accesses_val,
             )
         }
         0 => (quote!(()), quote!(()), quote!(), quote!(()), quote!(())),
         _ => {
             let mut returns_ref = TokenStream::new();
             let mut returns_val = TokenStream::new();
             let mut matches = TokenStream::new();
             let mut accesses_ref = TokenStream::new();
             let mut accesses_val = TokenStream::new();

             for (i, field) in fields.unnamed.iter().enumerate() {
                 let rt = &field.ty;
                 let match_name = Ident::new(&format!("match_{}", i), Span::call_site());
                 returns_ref.extend(quote!(&#rt,));
                 returns_val.extend(quote!(#rt,));
                 matches.extend(quote!(#match_name,));
                 accesses_ref.extend(quote!(&#match_name,));
                 accesses_val.extend(quote!(#match_name,));
             }

             (
                 quote!((#returns_ref)),
                 quote!((#returns_val)),
                 quote!(#matches),
                 quote!((#accesses_ref)),
                 quote!((#accesses_val)),
             )
         }
     };

     quote!(
         #[doc = #doc_ref ]
         pub fn #function_name_ref(&self) -> Option<#returns_ref> {
             match self {
                 #name::#variant_name(#matches) => {
                     Some(#accesses_ref)
                 }
                 _ => None
             }
         }

         #[doc = #doc_val ]
         pub fn #function_name_val(self) -> ::core::result::Result<#returns_val, Self> {
             match self {
                 #name::#variant_name(#matches) => {
                     Ok(#accesses_val)
                 },
                 _ => Err(self)
             }
         }
     )
 }

 /// returns first the types to return, the match names, and then tokens to the field accesses
 fn named_fields_return(
     name: &syn::Ident,
     variant_name: &syn::Ident,
     (function_name_ref, doc_ref): (&Ident, &str),
     (function_name_val, doc_val): (&Ident, &str),
     fields: &syn::FieldsNamed,
 ) -> TokenStream {
     let (returns_ref, returns_val, matches, accesses_ref, accesses_val) = match fields.named.len() {
         1 => {
             let field = fields.named.first().expect("no fields on type");
             let match_name = field.ident.as_ref().expect("expected a named field");

             let returns = &field.ty;
             let returns_ref = quote!(&#returns);
             let returns_val = quote!(#returns);
             let matches = quote!(#match_name);
             let accesses_ref = quote!(&#match_name);
             let accesses_val = quote!(#match_name);

             (
                 returns_ref,
                 returns_val,
                 matches,
                 accesses_ref,
                 accesses_val,
             )
         }
         0 => (quote!(()), quote!(()), quote!(), quote!(()), quote!(())),
         _ => {
             let mut returns_ref = TokenStream::new();
             let mut returns_val = TokenStream::new();
             let mut matches = TokenStream::new();
             let mut accesses_ref = TokenStream::new();
             let mut accesses_val = TokenStream::new();

             for field in fields.named.iter() {
                 let rt = &field.ty;
                 let match_name = field.ident.as_ref().expect("expected a named field");

                 returns_ref.extend(quote!(&#rt,));
                 returns_val.extend(quote!(#rt,));
                 matches.extend(quote!(#match_name,));
                 accesses_ref.extend(quote!(&#match_name,));
                 accesses_val.extend(quote!(#match_name,));
             }

             (
                 quote!((#returns_ref)),
                 quote!((#returns_val)),
                 quote!(#matches),
                 quote!((#accesses_ref)),
                 quote!((#accesses_val)),
             )
         }
     };

     quote!(
         #[doc = #doc_ref ]
         pub fn #function_name_ref(&self) -> Option<#returns_ref> {
             match self {
                 #name::#variant_name{ #matches } => {
                     Some(#accesses_ref)
                 }
                 _ => None
             }
         }

         #[doc = #doc_val ]
         pub fn #function_name_val(self) -> ::core::result::Result<#returns_val, Self> {
             match self {
                 #name::#variant_name{ #matches } => {
                     Ok(#accesses_val)
                 }
                 _ => Err(self)
             }
         }
     )
 }

 fn impl_all_as_fns(ast: &DeriveInput) -> TokenStream {
     let name = &ast.ident;

     let enum_data = if let syn::Data::Enum(data) = &ast.data {
         data
     } else {
         panic!("{} is not an enum", name);
     };

     let mut stream = TokenStream::new();

     for variant_data in &enum_data.variants {
         let variant_name = &variant_data.ident;
         let function_name_ref = Ident::new(
             &format!("as_{}", variant_name).to_snake_case(),
             Span::call_site(),
         );
         let doc_ref = format!(
             "Optionally returns references to the inner fields if this is a `{}::{}`, otherwise `None`",
             name,
             variant_name,
         );
         let function_name_val = Ident::new(
             &format!("into_{}", variant_name).to_snake_case(),
             Span::call_site(),
         );
         let doc_val = format!(
             "Returns the inner fields if this is a `{}::{}`, otherwise returns back the enum in the `Err` case of the result",
             name,
             variant_name,
         );

         let tokens = match &variant_data.fields {
             syn::Fields::Unit => {
                 unit_fields_return(name, variant_name, &function_name_ref, &doc_ref)
             }
             syn::Fields::Unnamed(unnamed) => unnamed_fields_return(
                 name,
                 variant_name,
                 (&function_name_ref, &doc_ref),
                 (&function_name_val, &doc_val),
                 &unnamed,
             ),
             syn::Fields::Named(named) => named_fields_return(
                 name,
                 variant_name,
                 (&function_name_ref, &doc_ref),
                 (&function_name_val, &doc_val),
                 &named,
             ),
         };

         stream.extend(tokens);
     }

     quote!(
         impl #name {
             #stream
         }
     )
 }

 #[proc_macro_derive(EnumAsInner)]
 pub fn enum_as_inner(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     // get a usable token stream
     let ast: DeriveInput = parse_macro_input!(input as DeriveInput);

     // Build the impl
     let expanded: TokenStream = impl_all_as_fns(&ast);

     // Return the generated impl
     proc_macro::TokenStream::from(expanded)
 }
	// Copyright 2015-2018 Benjamin Fry <benjaminfry@me.com>
	//
	// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
	// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
	// http://opensource.org/licenses/MIT>, at your option. This file may not be
	// copied, modified, or distributed except according to those terms.

	//! # enum-as-inner
	//!
	//! A deriving proc-macro for generating functions to automatically give access to the inner members of enum.
	//!
	//! ## Basic unnamed field case
	//!
	//! The basic case is meant for single item enums, like:
	//!
	//! ```rust
	//! # #[macro_use] extern crate enum_as_inner;
	//! # fn main() {
	//!
	//! #[derive(Debug, EnumAsInner)]
	//! enum OneEnum {
	//! One(u32),
	//! }
	//!
	//! let one = OneEnum::One(1);
	//!
	//! assert_eq!(*one.as_one().unwrap(), 1);
	//! assert_eq!(one.into_one().unwrap(), 1);
	//! # }
	//! ```
	//!
	//! where the result is either a reference for inner items or a tuple containing the inner items.
	//!
	//! ## Unit case
	//!
	//! This will return copy's of the value of the unit variant, as `isize`:
	//!
	//! ```rust
	//! # #[macro_use] extern crate enum_as_inner;
	//! # fn main() {
	//!
	//! #[derive(EnumAsInner)]
	//! enum UnitVariants {
	//! Zero,
	//! One,
	//! Two,
	//! }
	//!
	//! let unit = UnitVariants::Two;
	//!
	//! assert_eq!(unit.as_two().unwrap(), ());
	//! # }
	//! ```
	//!
	//! Note that for unit enums there is no `into_*()` function generated.
	//!
	//! ## Mutliple, unnamed field case
	//!
	//! This will return a tuple of the inner types:
	//!
	//! ```rust
	//! # #[macro_use] extern crate enum_as_inner;
	//! # fn main() {
	//!
	//! #[derive(Debug, EnumAsInner)]
	//! enum ManyVariants {
	//! One(u32),
	//! Two(u32, i32),
	//! Three(bool, u32, i64),
	//! }
	//!
	//! let many = ManyVariants::Three(true, 1, 2);
	//!
	//! assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
	//! assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));
	//! # }
	//! ```
	//!
	//! ## Multiple, named field case
	//!
	//! This will return a tuple of the inner types, like the unnamed option:
	//!
	//! ```rust
	//! # #[macro_use] extern crate enum_as_inner;
	//! # fn main() {
	//!
	//! #[derive(Debug, EnumAsInner)]
	//! enum ManyVariants {
	//! One { one: u32 },
	//! Two { one: u32, two: i32 },
	//! Three { one: bool, two: u32, three: i64 },
	//! }
	//!
	//! let many = ManyVariants::Three { one: true, two: 1, three: 2 };
	//!
	//! assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
	//! assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));
	//! # }
	//! ```

	extern crate proc_macro;
	extern crate proc_macro2;
	#[macro_use]
	extern crate syn;
	#[macro_use]
	extern crate quote;

	use heck::SnakeCase;
	use proc_macro2::{Ident, Span, TokenStream};
	use syn::DeriveInput;

	/// returns first the types to return, the match names, and then tokens to the field accesses
	fn unit_fields_return(
	name: &syn::Ident,
	variant_name: &syn::Ident,
	function_name: &Ident,
	doc: &str,
	) -> TokenStream {
	quote!(
	#[doc = #doc ]
	pub fn #function_name(&self) -> Option<()> {
	match self {
	#name::#variant_name => {
	Some(())
	}
	_ => None
	}
	}
	)
	}

	/// returns first the types to return, the match names, and then tokens to the field accesses
	fn unnamed_fields_return(
	name: &syn::Ident,
	variant_name: &syn::Ident,
	(function_name_ref, doc_ref): (&Ident, &str),
	(function_name_val, doc_val): (&Ident, &str),
	fields: &syn::FieldsUnnamed,
	) -> TokenStream {
	let (returns_ref, returns_val, matches, accesses_ref, accesses_val) = match fields.unnamed.len()
	{
	1 => {
	let field = fields.unnamed.first().expect("no fields on type");

	let returns = &field.ty;
	let returns_ref = quote!(&#returns);
	let returns_val = quote!(#returns);
	let matches = quote!(inner);
	let accesses_ref = quote!(&inner);
	let accesses_val = quote!(inner);

	(
	returns_ref,
	returns_val,
	matches,
	accesses_ref,
	accesses_val,
	)
	}
	0 => (quote!(()), quote!(()), quote!(), quote!(()), quote!(())),
	_ => {
	let mut returns_ref = TokenStream::new();
	let mut returns_val = TokenStream::new();
	let mut matches = TokenStream::new();
	let mut accesses_ref = TokenStream::new();
	let mut accesses_val = TokenStream::new();

	for (i, field) in fields.unnamed.iter().enumerate() {
	let rt = &field.ty;
	let match_name = Ident::new(&format!("match_{}", i), Span::call_site());
	returns_ref.extend(quote!(&#rt,));
	returns_val.extend(quote!(#rt,));
	matches.extend(quote!(#match_name,));
	accesses_ref.extend(quote!(&#match_name,));
	accesses_val.extend(quote!(#match_name,));
	}

	(
	quote!((#returns_ref)),
	quote!((#returns_val)),
	quote!(#matches),
	quote!((#accesses_ref)),
	quote!((#accesses_val)),
	)
	}
	};

	quote!(
	#[doc = #doc_ref ]
	pub fn #function_name_ref(&self) -> Option<#returns_ref> {
	match self {
	#name::#variant_name(#matches) => {
	Some(#accesses_ref)
	}
	_ => None
	}
	}

	#[doc = #doc_val ]
	pub fn #function_name_val(self) -> ::core::result::Result<#returns_val, Self> {
	match self {
	#name::#variant_name(#matches) => {
	Ok(#accesses_val)
	},
	_ => Err(self)
	}
	}
	)
	}

	/// returns first the types to return, the match names, and then tokens to the field accesses
	fn named_fields_return(
	name: &syn::Ident,
	variant_name: &syn::Ident,
	(function_name_ref, doc_ref): (&Ident, &str),
	(function_name_val, doc_val): (&Ident, &str),
	fields: &syn::FieldsNamed,
	) -> TokenStream {
	let (returns_ref, returns_val, matches, accesses_ref, accesses_val) = match fields.named.len() {
	1 => {
	let field = fields.named.first().expect("no fields on type");
	let match_name = field.ident.as_ref().expect("expected a named field");

	let returns = &field.ty;
	let returns_ref = quote!(&#returns);
	let returns_val = quote!(#returns);
	let matches = quote!(#match_name);
	let accesses_ref = quote!(&#match_name);
	let accesses_val = quote!(#match_name);

	(
	returns_ref,
	returns_val,
	matches,
	accesses_ref,
	accesses_val,
	)
	}
	0 => (quote!(()), quote!(()), quote!(), quote!(()), quote!(())),
	_ => {
	let mut returns_ref = TokenStream::new();
	let mut returns_val = TokenStream::new();
	let mut matches = TokenStream::new();
	let mut accesses_ref = TokenStream::new();
	let mut accesses_val = TokenStream::new();

	for field in fields.named.iter() {
	let rt = &field.ty;
	let match_name = field.ident.as_ref().expect("expected a named field");

	returns_ref.extend(quote!(&#rt,));
	returns_val.extend(quote!(#rt,));
	matches.extend(quote!(#match_name,));
	accesses_ref.extend(quote!(&#match_name,));
	accesses_val.extend(quote!(#match_name,));
	}

	(
	quote!((#returns_ref)),
	quote!((#returns_val)),
	quote!(#matches),
	quote!((#accesses_ref)),
	quote!((#accesses_val)),
	)
	}
	};

	quote!(
	#[doc = #doc_ref ]
	pub fn #function_name_ref(&self) -> Option<#returns_ref> {
	match self {
	#name::#variant_name{ #matches } => {
	Some(#accesses_ref)
	}
	_ => None
	}
	}

	#[doc = #doc_val ]
	pub fn #function_name_val(self) -> ::core::result::Result<#returns_val, Self> {
	match self {
	#name::#variant_name{ #matches } => {
	Ok(#accesses_val)
	}
	_ => Err(self)
	}
	}
	)
	}

	fn impl_all_as_fns(ast: &DeriveInput) -> TokenStream {
	let name = &ast.ident;

	let enum_data = if let syn::Data::Enum(data) = &ast.data {
	data
	} else {
	panic!("{} is not an enum", name);
	};

	let mut stream = TokenStream::new();

	for variant_data in &enum_data.variants {
	let variant_name = &variant_data.ident;
	let function_name_ref = Ident::new(
	&format!("as_{}", variant_name).to_snake_case(),
	Span::call_site(),
	);
	let doc_ref = format!(
	"Optionally returns references to the inner fields if this is a `{}::{}`, otherwise `None`",
	name,
	variant_name,
	);
	let function_name_val = Ident::new(
	&format!("into_{}", variant_name).to_snake_case(),
	Span::call_site(),
	);
	let doc_val = format!(
	"Returns the inner fields if this is a `{}::{}`, otherwise returns back the enum in the `Err` case of the result",
	name,
	variant_name,
	);

	let tokens = match &variant_data.fields {
	syn::Fields::Unit => {
	unit_fields_return(name, variant_name, &function_name_ref, &doc_ref)
	}
	syn::Fields::Unnamed(unnamed) => unnamed_fields_return(
	name,
	variant_name,
	(&function_name_ref, &doc_ref),
	(&function_name_val, &doc_val),
	&unnamed,
	),
	syn::Fields::Named(named) => named_fields_return(
	name,
	variant_name,
	(&function_name_ref, &doc_ref),
	(&function_name_val, &doc_val),
	&named,
	),
	};

	stream.extend(tokens);
	}

	quote!(
	impl #name {
	#stream
	}
	)
	}

	#[proc_macro_derive(EnumAsInner)]
	pub fn enum_as_inner(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
	// get a usable token stream
	let ast: DeriveInput = parse_macro_input!(input as DeriveInput);

	// Build the impl
	let expanded: TokenStream = impl_all_as_fns(&ast);

	// Return the generated impl
	proc_macro::TokenStream::from(expanded)
	}