diff options
| author | mo khan <mo@mokhan.ca> | 2025-07-15 16:37:08 -0600 |
|---|---|---|
| committer | mo khan <mo@mokhan.ca> | 2025-07-17 16:30:22 -0600 |
| commit | 45df4d0d9b577fecee798d672695fe24ff57fb1b (patch) | |
| tree | 1b99bf645035b58e0d6db08c7a83521f41f7a75b /vendor/educe/src | |
| parent | f94f79608393d4ab127db63cc41668445ef6b243 (diff) | |
feat: migrate from Cedar to SpiceDB authorization system
This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.
Key changes:
- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization
This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.
Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.
Diffstat (limited to 'vendor/educe/src')
101 files changed, 0 insertions, 12024 deletions
diff --git a/vendor/educe/src/common/bound.rs b/vendor/educe/src/common/bound.rs deleted file mode 100644 index 78f9aed4..00000000 --- a/vendor/educe/src/common/bound.rs +++ /dev/null @@ -1,57 +0,0 @@ -use syn::{punctuated::Punctuated, token::Comma, GenericParam, Meta, Path, Type, WherePredicate}; - -use crate::common::where_predicates_bool::{ - create_where_predicates_from_all_generic_parameters, - create_where_predicates_from_generic_parameters_check_types, meta_2_where_predicates, - WherePredicates, WherePredicatesOrBool, -}; - -pub(crate) enum Bound { - Disabled, - Auto, - Custom(WherePredicates), - All, -} - -impl Bound { - #[inline] - pub(crate) fn from_meta(meta: &Meta) -> syn::Result<Self> { - debug_assert!(meta.path().is_ident("bound")); - - Ok(match meta_2_where_predicates(meta)? { - WherePredicatesOrBool::WherePredicates(where_predicates) => { - Self::Custom(where_predicates) - }, - WherePredicatesOrBool::Bool(b) => { - if b { - Self::Auto - } else { - Self::Disabled - } - }, - WherePredicatesOrBool::All => Self::All, - }) - } -} - -impl Bound { - #[inline] - pub(crate) fn into_where_predicates_by_generic_parameters_check_types( - self, - params: &Punctuated<GenericParam, Comma>, - bound_trait: &Path, - types: &[&Type], - supertraits: &[proc_macro2::TokenStream], - ) -> Punctuated<WherePredicate, Comma> { - match self { - Self::Disabled => Punctuated::new(), - Self::Auto => create_where_predicates_from_generic_parameters_check_types( - bound_trait, - types, - supertraits, - ), - Self::Custom(where_predicates) => where_predicates, - Self::All => create_where_predicates_from_all_generic_parameters(params, bound_trait), - } - } -} diff --git a/vendor/educe/src/common/expr.rs b/vendor/educe/src/common/expr.rs deleted file mode 100644 index ab49d3a0..00000000 --- a/vendor/educe/src/common/expr.rs +++ /dev/null @@ -1,109 +0,0 @@ -use quote::{quote, ToTokens}; -use syn::{spanned::Spanned, Expr, Lit, Meta, Type}; - -use super::path::path_to_string; - -const INT_TYPES: [&str; 12] = - ["u8", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]; - -const FLOAT_TYPES: [&str; 2] = ["f32", "f64"]; - -#[inline] -pub(crate) fn meta_2_expr(meta: &Meta) -> syn::Result<Expr> { - match &meta { - Meta::NameValue(name_value) => Ok(name_value.value.clone()), - Meta::List(list) => list.parse_args::<Expr>(), - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!("expected `{path} = Expr` or `{path}(Expr)`", path = path_to_string(path)), - )), - } -} - -#[inline] -pub(crate) fn auto_adjust_expr(expr: Expr, ty: Option<&Type>) -> Expr { - match &expr { - Expr::Lit(lit) => { - match &lit.lit { - Lit::Int(lit) => { - if let Some(Type::Path(ty)) = ty { - let ty_string = ty.into_token_stream().to_string(); - - if lit.suffix() == ty_string || INT_TYPES.contains(&ty_string.as_str()) { - // don't call into - return expr; - } - } - }, - Lit::Float(lit) => { - if let Some(Type::Path(ty)) = ty { - let ty_string = ty.into_token_stream().to_string(); - - if lit.suffix() == ty_string || FLOAT_TYPES.contains(&ty_string.as_str()) { - // don't call into - return expr; - } - } - }, - Lit::Str(_) => { - if let Some(Type::Reference(ty)) = ty { - let ty_string = ty.elem.clone().into_token_stream().to_string(); - - if ty_string == "str" { - // don't call into - return expr; - } - } - }, - Lit::Bool(_) => { - if let Some(Type::Path(ty)) = ty { - let ty_string = ty.into_token_stream().to_string(); - - if ty_string == "bool" { - // don't call into - return expr; - } - } - }, - Lit::Char(_) => { - if let Some(Type::Path(ty)) = ty { - let ty_string = ty.into_token_stream().to_string(); - - if ty_string == "char" { - // don't call into - return expr; - } - } - }, - Lit::Byte(_) => { - if let Some(Type::Path(ty)) = ty { - let ty_string = ty.into_token_stream().to_string(); - - if ty_string == "u8" { - // don't call into - return expr; - } - } - }, - Lit::ByteStr(_) => { - if let Some(Type::Reference(ty)) = ty { - if let Type::Array(ty) = ty.elem.as_ref() { - if let Type::Path(ty) = ty.elem.as_ref() { - let ty_string = ty.into_token_stream().to_string(); - - if ty_string == "u8" { - // don't call into - return expr; - } - } - } - } - }, - _ => (), - } - - syn::parse2(quote!(::core::convert::Into::into(#expr))).unwrap() - }, - _ => expr, - } -} diff --git a/vendor/educe/src/common/ident_bool.rs b/vendor/educe/src/common/ident_bool.rs deleted file mode 100644 index 89bf2fb9..00000000 --- a/vendor/educe/src/common/ident_bool.rs +++ /dev/null @@ -1,161 +0,0 @@ -use syn::{ - parse::{Parse, ParseStream}, - spanned::Spanned, - Expr, Ident, Lit, LitBool, LitStr, Meta, MetaNameValue, -}; - -use super::path::path_to_string; - -#[derive(Debug)] -pub(crate) enum IdentOrBool { - Ident(Ident), - Bool(bool), -} - -impl Parse for IdentOrBool { - #[inline] - fn parse(input: ParseStream) -> syn::Result<Self> { - if let Ok(lit) = input.parse::<Lit>() { - match lit { - Lit::Bool(lit) => return Ok(Self::Bool(lit.value)), - Lit::Str(lit) => { - return match lit.parse::<Ident>() { - Ok(ident) => Ok(Self::Ident(ident)), - Err(_) if lit.value().is_empty() => Ok(Self::Bool(false)), - Err(error) => Err(error), - } - }, - _ => (), - } - } - - Ok(Self::Ident(input.parse::<Ident>()?)) - } -} - -#[inline] -pub(crate) fn meta_name_value_2_ident(name_value: &MetaNameValue) -> syn::Result<Ident> { - match &name_value.value { - Expr::Lit(lit) => { - if let Lit::Str(lit) = &lit.lit { - return lit.parse(); - } - }, - Expr::Path(path) => { - if let Some(ident) = path.path.get_ident() { - return Ok(ident.clone()); - } - }, - _ => (), - } - - Err(syn::Error::new( - name_value.value.span(), - format!("expected `{path} = Ident`", path = path_to_string(&name_value.path)), - )) -} - -#[inline] -pub(crate) fn meta_2_ident(meta: &Meta) -> syn::Result<Ident> { - match &meta { - Meta::NameValue(name_value) => meta_name_value_2_ident(name_value), - Meta::List(list) => { - if let Ok(lit) = list.parse_args::<LitStr>() { - lit.parse() - } else { - list.parse_args() - } - }, - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!("expected `{path} = Ident` or `{path}(Ident)`", path = path_to_string(path)), - )), - } -} - -#[inline] -pub(crate) fn meta_name_value_2_bool(name_value: &MetaNameValue) -> syn::Result<bool> { - if let Expr::Lit(lit) = &name_value.value { - if let Lit::Bool(b) = &lit.lit { - return Ok(b.value); - } - } - - Err(syn::Error::new( - name_value.value.span(), - format!("expected `{path} = false`", path = path_to_string(&name_value.path)), - )) -} - -#[inline] -pub(crate) fn meta_2_bool(meta: &Meta) -> syn::Result<bool> { - match &meta { - Meta::NameValue(name_value) => meta_name_value_2_bool(name_value), - Meta::List(list) => Ok(list.parse_args::<LitBool>()?.value), - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!("expected `{path} = false` or `{path}(false)`", path = path_to_string(path)), - )), - } -} - -#[inline] -pub(crate) fn meta_2_bool_allow_path(meta: &Meta) -> syn::Result<bool> { - match &meta { - Meta::Path(_) => Ok(true), - Meta::NameValue(name_value) => meta_name_value_2_bool(name_value), - Meta::List(list) => Ok(list.parse_args::<LitBool>()?.value), - } -} - -#[inline] -pub(crate) fn meta_name_value_2_ident_and_bool( - name_value: &MetaNameValue, -) -> syn::Result<IdentOrBool> { - match &name_value.value { - Expr::Lit(lit) => match &lit.lit { - Lit::Str(lit) => match lit.parse::<Ident>() { - Ok(ident) => return Ok(IdentOrBool::Ident(ident)), - Err(_) if lit.value().is_empty() => { - return Ok(IdentOrBool::Bool(false)); - }, - Err(error) => { - return Err(error); - }, - }, - Lit::Bool(lit) => { - return Ok(IdentOrBool::Bool(lit.value)); - }, - _ => (), - }, - Expr::Path(path) => { - if let Some(ident) = path.path.get_ident() { - return Ok(IdentOrBool::Ident(ident.clone())); - } - }, - _ => (), - } - - Err(syn::Error::new( - name_value.value.span(), - format!( - "expected `{path} = Ident` or `{path} = false`", - path = path_to_string(&name_value.path) - ), - )) -} - -#[inline] -pub(crate) fn meta_2_ident_and_bool(meta: &Meta) -> syn::Result<IdentOrBool> { - match &meta { - Meta::NameValue(name_value) => meta_name_value_2_ident_and_bool(name_value), - Meta::List(list) => list.parse_args::<IdentOrBool>(), - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!( - "expected `{path} = Ident`, `{path}(Ident)`, `{path} = false`, or `{path}(false)`", - path = path_to_string(path) - ), - )), - } -} diff --git a/vendor/educe/src/common/ident_index.rs b/vendor/educe/src/common/ident_index.rs deleted file mode 100644 index c0e38d49..00000000 --- a/vendor/educe/src/common/ident_index.rs +++ /dev/null @@ -1,56 +0,0 @@ -use quote::ToTokens; -use syn::{Ident, Index}; - -pub(crate) enum IdentOrIndex { - Ident(Ident), - Index(Index), -} - -impl From<Ident> for IdentOrIndex { - #[inline] - fn from(value: Ident) -> Self { - Self::Ident(value) - } -} - -impl From<Index> for IdentOrIndex { - #[inline] - fn from(value: Index) -> Self { - Self::Index(value) - } -} - -impl From<&Ident> for IdentOrIndex { - #[inline] - fn from(value: &Ident) -> Self { - Self::Ident(value.clone()) - } -} - -impl From<usize> for IdentOrIndex { - #[inline] - fn from(value: usize) -> Self { - Self::Index(Index::from(value)) - } -} - -impl ToTokens for IdentOrIndex { - #[inline] - fn to_tokens(&self, token_stream: &mut proc_macro2::TokenStream) { - match self { - Self::Ident(ident) => ToTokens::to_tokens(ident, token_stream), - Self::Index(index) => ToTokens::to_tokens(index, token_stream), - } - } -} - -impl IdentOrIndex { - #[inline] - pub(crate) fn from_ident_with_index(ident: Option<&Ident>, index: usize) -> IdentOrIndex { - if let Some(ident) = ident { - Self::from(ident) - } else { - Self::from(index) - } - } -} diff --git a/vendor/educe/src/common/int.rs b/vendor/educe/src/common/int.rs deleted file mode 100644 index ae52b491..00000000 --- a/vendor/educe/src/common/int.rs +++ /dev/null @@ -1,63 +0,0 @@ -use syn::{spanned::Spanned, Expr, Lit, Meta, MetaNameValue, UnOp}; - -use super::path::path_to_string; - -#[inline] -pub(crate) fn meta_name_value_2_isize(name_value: &MetaNameValue) -> syn::Result<isize> { - match &name_value.value { - Expr::Lit(lit) => match &lit.lit { - Lit::Str(lit) => { - return lit - .value() - .parse::<isize>() - .map_err(|error| syn::Error::new(lit.span(), error)) - }, - Lit::Int(lit) => return lit.base10_parse(), - _ => (), - }, - Expr::Unary(unary) => { - if let UnOp::Neg(_) = unary.op { - if let Expr::Lit(lit) = unary.expr.as_ref() { - if let Lit::Int(lit) = &lit.lit { - let s = format!("-{}", lit.base10_digits()); - - return s - .parse::<isize>() - .map_err(|error| syn::Error::new(lit.span(), error)); - } - } - } - }, - _ => (), - } - - Err(syn::Error::new( - name_value.value.span(), - format!("expected `{path} = integer`", path = path_to_string(&name_value.path)), - )) -} - -#[inline] -pub(crate) fn meta_2_isize(meta: &Meta) -> syn::Result<isize> { - match &meta { - Meta::NameValue(name_value) => meta_name_value_2_isize(name_value), - Meta::List(list) => { - let lit = list.parse_args::<Lit>()?; - - match &lit { - Lit::Str(lit) => { - lit.value().parse::<isize>().map_err(|error| syn::Error::new(lit.span(), error)) - }, - Lit::Int(lit) => lit.base10_parse(), - _ => Err(syn::Error::new(lit.span(), "not an integer")), - } - }, - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!( - "expected `{path} = integer` or `{path}(integer)`", - path = path_to_string(path) - ), - )), - } -} diff --git a/vendor/educe/src/common/mod.rs b/vendor/educe/src/common/mod.rs deleted file mode 100644 index 79e10bb9..00000000 --- a/vendor/educe/src/common/mod.rs +++ /dev/null @@ -1,43 +0,0 @@ -#[allow(dead_code)] -pub(crate) mod bound; -#[allow(dead_code)] -pub(crate) mod path; -#[allow(dead_code)] -pub(crate) mod r#type; -#[allow(dead_code)] -pub(crate) mod where_predicates_bool; - -#[cfg(feature = "Default")] -#[allow(dead_code)] -pub(crate) mod expr; -#[cfg(any( - feature = "Debug", - feature = "PartialEq", - feature = "PartialOrd", - feature = "Ord", - feature = "Hash", - feature = "Default" -))] -#[allow(dead_code)] -pub(crate) mod ident_bool; -#[cfg(any( - feature = "Debug", - feature = "PartialEq", - feature = "PartialOrd", - feature = "Ord", - feature = "Hash", - feature = "Deref", - feature = "DerefMut", - feature = "Into" -))] -#[allow(dead_code)] -pub(crate) mod ident_index; -#[cfg(any(feature = "PartialOrd", feature = "Ord"))] -#[allow(dead_code)] -pub(crate) mod int; -#[cfg(any(feature = "Debug", feature = "PartialEq", feature = "Hash"))] -#[allow(dead_code)] -pub(crate) mod unsafe_punctuated_meta; - -#[cfg(any(feature = "PartialOrd", feature = "Ord", feature = "Into"))] -pub(crate) mod tools; diff --git a/vendor/educe/src/common/path.rs b/vendor/educe/src/common/path.rs deleted file mode 100644 index 18f80b24..00000000 --- a/vendor/educe/src/common/path.rs +++ /dev/null @@ -1,43 +0,0 @@ -use quote::ToTokens; -use syn::{spanned::Spanned, Expr, Lit, LitStr, Meta, MetaNameValue, Path}; - -#[inline] -pub(crate) fn meta_name_value_2_path(name_value: &MetaNameValue) -> syn::Result<Path> { - match &name_value.value { - Expr::Lit(lit) => { - if let Lit::Str(lit) = &lit.lit { - return lit.parse(); - } - }, - Expr::Path(path) => return Ok(path.path.clone()), - _ => (), - } - - Err(syn::Error::new( - name_value.value.span(), - format!("expected `{path} = Path`", path = path_to_string(&name_value.path)), - )) -} - -#[inline] -pub(crate) fn meta_2_path(meta: &Meta) -> syn::Result<Path> { - match &meta { - Meta::NameValue(name_value) => meta_name_value_2_path(name_value), - Meta::List(list) => { - if let Ok(lit) = list.parse_args::<LitStr>() { - lit.parse() - } else { - list.parse_args() - } - }, - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!("expected `{path} = Path` or `{path}(Path)`", path = path_to_string(path)), - )), - } -} - -#[inline] -pub(crate) fn path_to_string(path: &Path) -> String { - path.into_token_stream().to_string().replace(' ', "") -} diff --git a/vendor/educe/src/common/tools/discriminant_type.rs b/vendor/educe/src/common/tools/discriminant_type.rs deleted file mode 100644 index 5bc0d2f8..00000000 --- a/vendor/educe/src/common/tools/discriminant_type.rs +++ /dev/null @@ -1,169 +0,0 @@ -use proc_macro2::{Ident, Span, TokenStream}; -use quote::{ToTokens, TokenStreamExt}; -use syn::{ - punctuated::Punctuated, spanned::Spanned, Data, DeriveInput, Expr, Lit, Meta, Token, UnOp, -}; - -#[derive(Debug)] -pub(crate) enum DiscriminantType { - ISize, - I8, - I16, - I32, - I64, - I128, - USize, - U8, - U16, - U32, - U64, - U128, -} - -impl DiscriminantType { - #[inline] - pub(crate) fn parse_str<S: AsRef<str>>(s: S) -> Option<Self> { - match s.as_ref() { - "i8" => Some(Self::I8), - "i16" => Some(Self::I16), - "i32" => Some(Self::I32), - "i64" => Some(Self::I64), - "i128" => Some(Self::I128), - "isize" => Some(Self::ISize), - "u8" => Some(Self::U8), - "u16" => Some(Self::U16), - "u32" => Some(Self::U32), - "u64" => Some(Self::U64), - "u128" => Some(Self::U128), - "usize" => Some(Self::USize), - _ => None, - } - } - - #[inline] - pub(crate) const fn as_str(&self) -> &'static str { - match self { - Self::ISize => "isize", - Self::I8 => "i8", - Self::I16 => "i16", - Self::I32 => "i32", - Self::I64 => "i64", - Self::I128 => "i128", - Self::USize => "usize", - Self::U8 => "u8", - Self::U16 => "u16", - Self::U32 => "u32", - Self::U64 => "u64", - Self::U128 => "u128", - } - } -} - -impl ToTokens for DiscriminantType { - #[inline] - fn to_tokens(&self, tokens: &mut TokenStream) { - tokens.append(Ident::new(self.as_str(), Span::call_site())); - } -} - -impl DiscriminantType { - pub(crate) fn from_ast(ast: &DeriveInput) -> syn::Result<Self> { - if let Data::Enum(data) = &ast.data { - for attr in ast.attrs.iter() { - if attr.path().is_ident("repr") { - // #[repr(u8)], #[repr(u16)], ..., etc. - if let Meta::List(list) = &attr.meta { - let result = - list.parse_args_with(Punctuated::<Ident, Token![,]>::parse_terminated)?; - - if let Some(value) = result.into_iter().next() { - if let Some(t) = Self::parse_str(value.to_string()) { - return Ok(t); - } - } - } - } - } - - let mut min = i128::MAX; - let mut max = i128::MIN; - let mut counter = 0i128; - - for variant in data.variants.iter() { - if let Some((_, exp)) = variant.discriminant.as_ref() { - match exp { - Expr::Lit(lit) => { - if let Lit::Int(lit) = &lit.lit { - counter = lit - .base10_parse() - .map_err(|error| syn::Error::new(lit.span(), error))?; - } else { - return Err(syn::Error::new(lit.span(), "not an integer")); - } - }, - Expr::Unary(unary) => { - if let UnOp::Neg(_) = unary.op { - if let Expr::Lit(lit) = unary.expr.as_ref() { - if let Lit::Int(lit) = &lit.lit { - match lit.base10_parse::<i128>() { - Ok(i) => { - counter = -i; - }, - Err(error) => { - // overflow - if lit.base10_digits() - == "170141183460469231731687303715884105728" - { - counter = i128::MIN; - } else { - return Err(syn::Error::new(lit.span(), error)); - } - }, - } - } else { - return Err(syn::Error::new(lit.span(), "not an integer")); - } - } else { - return Err(syn::Error::new( - unary.expr.span(), - "not a literal", - )); - } - } else { - return Err(syn::Error::new( - unary.op.span(), - "this operation is not allow here", - )); - } - }, - _ => return Err(syn::Error::new(exp.span(), "not a literal")), - } - } - - if min > counter { - min = counter; - } - - if max < counter { - max = counter; - } - - counter = counter.saturating_add(1); - } - - Ok(if min >= i8::MIN as i128 && max <= i8::MAX as i128 { - Self::I8 - } else if min >= i16::MIN as i128 && max <= i16::MAX as i128 { - Self::I16 - } else if min >= i32::MIN as i128 && max <= i32::MAX as i128 { - Self::I32 - } else if min >= i64::MIN as i128 && max <= i64::MAX as i128 { - Self::I64 - } else { - Self::I128 - }) - } else { - Err(syn::Error::new(ast.span(), "not an enum")) - } - } -} diff --git a/vendor/educe/src/common/tools/hash_type.rs b/vendor/educe/src/common/tools/hash_type.rs deleted file mode 100644 index ece3d03f..00000000 --- a/vendor/educe/src/common/tools/hash_type.rs +++ /dev/null @@ -1,100 +0,0 @@ -use std::{ - cmp::Ordering, - fmt::{self, Display, Formatter}, - hash::{Hash, Hasher}, - str::FromStr, -}; - -use proc_macro2::Span; -use quote::ToTokens; -use syn::{spanned::Spanned, Path, Type}; - -#[derive(Debug, Clone)] -pub(crate) struct HashType(String, Span); - -impl PartialEq for HashType { - #[inline] - fn eq(&self, other: &Self) -> bool { - self.0.eq(&other.0) - } -} - -impl Eq for HashType {} - -impl PartialOrd for HashType { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option<Ordering> { - Some(self.cmp(other)) - } -} - -impl Ord for HashType { - #[inline] - fn cmp(&self, other: &Self) -> Ordering { - self.0.cmp(&other.0) - } -} - -impl Hash for HashType { - #[inline] - fn hash<H: Hasher>(&self, state: &mut H) { - Hash::hash(&self.0, state); - } -} - -impl Display for HashType { - #[inline] - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - Display::fmt(&self.0.replace("& '", "&'"), f) - } -} - -impl From<Type> for HashType { - #[inline] - fn from(value: Type) -> Self { - Self::from(&value) - } -} - -impl From<&Type> for HashType { - #[inline] - fn from(value: &Type) -> Self { - Self(value.into_token_stream().to_string(), value.span()) - } -} - -impl From<Path> for HashType { - #[inline] - fn from(value: Path) -> Self { - Self::from(&value) - } -} - -impl From<&Path> for HashType { - #[inline] - fn from(value: &Path) -> Self { - Self(value.into_token_stream().to_string(), value.span()) - } -} - -#[allow(dead_code)] -impl HashType { - #[inline] - pub(crate) fn to_type(&self) -> Type { - syn::parse_str(self.0.as_str()).unwrap() - } - - #[inline] - pub(crate) fn span(&self) -> Span { - self.1 - } -} - -impl ToTokens for HashType { - #[inline] - fn to_tokens(&self, token_stream: &mut proc_macro2::TokenStream) { - let ty = proc_macro2::TokenStream::from_str(self.0.as_str()).unwrap(); - - token_stream.extend(ty); - } -} diff --git a/vendor/educe/src/common/tools/mod.rs b/vendor/educe/src/common/tools/mod.rs deleted file mode 100644 index 23cb4970..00000000 --- a/vendor/educe/src/common/tools/mod.rs +++ /dev/null @@ -1,11 +0,0 @@ -#[cfg(any(feature = "PartialOrd", feature = "Ord"))] -mod discriminant_type; - -#[cfg(any(feature = "PartialOrd", feature = "Ord"))] -pub(crate) use discriminant_type::*; - -#[cfg(feature = "Into")] -mod hash_type; - -#[cfg(feature = "Into")] -pub(crate) use hash_type::*; diff --git a/vendor/educe/src/common/type.rs b/vendor/educe/src/common/type.rs deleted file mode 100644 index c17ed73b..00000000 --- a/vendor/educe/src/common/type.rs +++ /dev/null @@ -1,51 +0,0 @@ -use syn::{ - parse::{Parse, ParseStream}, - punctuated::Punctuated, - Meta, Token, Type, -}; - -pub(crate) struct TypeWithPunctuatedMeta { - pub(crate) ty: Type, - pub(crate) list: Punctuated<Meta, Token![,]>, -} - -impl Parse for TypeWithPunctuatedMeta { - #[inline] - fn parse(input: ParseStream) -> syn::Result<Self> { - let ty = input.parse::<Type>()?; - - if input.is_empty() { - return Ok(Self { - ty, - list: Punctuated::new(), - }); - } - - input.parse::<Token![,]>()?; - - let list = input.parse_terminated(Meta::parse, Token![,])?; - - Ok(Self { - ty, - list, - }) - } -} - -#[inline] -pub(crate) fn dereference(ty: &Type) -> &Type { - if let Type::Reference(ty) = ty { - dereference(ty.elem.as_ref()) - } else { - ty - } -} - -#[inline] -pub(crate) fn dereference_changed(ty: &Type) -> (&Type, bool) { - if let Type::Reference(ty) = ty { - (dereference(ty.elem.as_ref()), true) - } else { - (ty, false) - } -} diff --git a/vendor/educe/src/common/unsafe_punctuated_meta.rs b/vendor/educe/src/common/unsafe_punctuated_meta.rs deleted file mode 100644 index e8ec103b..00000000 --- a/vendor/educe/src/common/unsafe_punctuated_meta.rs +++ /dev/null @@ -1,35 +0,0 @@ -use syn::{ - parse::{Parse, ParseStream}, - punctuated::Punctuated, - Meta, Token, -}; - -pub(crate) struct UnsafePunctuatedMeta { - pub(crate) list: Punctuated<Meta, Token![,]>, - pub(crate) has_unsafe: bool, -} - -impl Parse for UnsafePunctuatedMeta { - #[inline] - fn parse(input: ParseStream) -> syn::Result<Self> { - let has_unsafe = input.parse::<Token![unsafe]>().is_ok(); - - if input.is_empty() { - return Ok(Self { - list: Punctuated::new(), - has_unsafe, - }); - } - - if has_unsafe { - input.parse::<Token![,]>()?; - } - - let list = input.parse_terminated(Meta::parse, Token![,])?; - - Ok(Self { - list, - has_unsafe, - }) - } -} diff --git a/vendor/educe/src/common/where_predicates_bool.rs b/vendor/educe/src/common/where_predicates_bool.rs deleted file mode 100644 index 4aa3695c..00000000 --- a/vendor/educe/src/common/where_predicates_bool.rs +++ /dev/null @@ -1,122 +0,0 @@ -use quote::{quote, ToTokens}; -use syn::{ - parse::{Parse, ParseStream}, - punctuated::Punctuated, - spanned::Spanned, - token::Comma, - Expr, GenericParam, Lit, Meta, MetaNameValue, Path, Token, Type, WherePredicate, -}; - -use super::path::path_to_string; - -pub(crate) type WherePredicates = Punctuated<WherePredicate, Token![,]>; - -pub(crate) enum WherePredicatesOrBool { - WherePredicates(WherePredicates), - Bool(bool), - All, -} - -impl WherePredicatesOrBool { - fn from_lit(lit: &Lit) -> syn::Result<Self> { - Ok(match lit { - Lit::Bool(lit) => Self::Bool(lit.value), - Lit::Str(lit) => match lit.parse_with(WherePredicates::parse_terminated) { - Ok(where_predicates) => Self::WherePredicates(where_predicates), - Err(_) if lit.value().is_empty() => Self::Bool(false), - Err(error) => return Err(error), - }, - other => { - return Err(syn::Error::new( - other.span(), - "unexpected kind of literal (only boolean or string allowed)", - )) - }, - }) - } -} - -impl Parse for WherePredicatesOrBool { - #[inline] - fn parse(input: ParseStream) -> syn::Result<Self> { - if let Ok(lit) = input.parse::<Lit>() { - return Self::from_lit(&lit); - } - - if let Ok(_star) = input.parse::<Token![*]>() { - return Ok(Self::All); - } - - Ok(Self::WherePredicates(input.parse_terminated(WherePredicate::parse, Token![,])?)) - } -} - -#[inline] -pub(crate) fn meta_name_value_2_where_predicates_bool( - name_value: &MetaNameValue, -) -> syn::Result<WherePredicatesOrBool> { - if let Expr::Lit(lit) = &name_value.value { - return WherePredicatesOrBool::from_lit(&lit.lit); - } - - Err(syn::Error::new( - name_value.value.span(), - format!( - "expected `{path} = \"where_predicates\"` or `{path} = false`", - path = path_to_string(&name_value.path) - ), - )) -} - -#[inline] -pub(crate) fn meta_2_where_predicates(meta: &Meta) -> syn::Result<WherePredicatesOrBool> { - match &meta { - Meta::NameValue(name_value) => meta_name_value_2_where_predicates_bool(name_value), - Meta::List(list) => list.parse_args::<WherePredicatesOrBool>(), - Meta::Path(path) => Err(syn::Error::new( - path.span(), - format!( - "expected `{path} = \"where_predicates\"`, `{path}(where_predicates)`, `{path} = \ - false`, or `{path}(false)`", - path = path.clone().into_token_stream() - ), - )), - } -} - -#[inline] -pub(crate) fn create_where_predicates_from_all_generic_parameters( - params: &Punctuated<GenericParam, Comma>, - bound_trait: &Path, -) -> WherePredicates { - let mut where_predicates = Punctuated::new(); - - for param in params { - if let GenericParam::Type(ty) = param { - let ident = &ty.ident; - - where_predicates.push(syn::parse2(quote! { #ident: #bound_trait }).unwrap()); - } - } - - where_predicates -} - -#[inline] -pub(crate) fn create_where_predicates_from_generic_parameters_check_types( - bound_trait: &Path, - types: &[&Type], - supertraits: &[proc_macro2::TokenStream], -) -> WherePredicates { - let mut where_predicates = Punctuated::new(); - - for t in types { - where_predicates.push(syn::parse2(quote! { #t: #bound_trait }).unwrap()); - } - - for supertrait in supertraits { - where_predicates.push(syn::parse2(quote! { Self: #supertrait }).unwrap()); - } - - where_predicates -} diff --git a/vendor/educe/src/lib.rs b/vendor/educe/src/lib.rs deleted file mode 100644 index 6b9a26e3..00000000 --- a/vendor/educe/src/lib.rs +++ /dev/null @@ -1,2135 +0,0 @@ -/*! -# Educe - -This crate offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits. - -## Features - -By default, every trait this crate supports will be enabled. You can disable all of them by turning off the default features and enable only the traits that you want to use by adding them to the `features` explicitly. - -For example, - -```toml -[dependencies.educe] -version = "*" -features = ["Debug", "Clone", "Copy", "Hash", "Default"] -default-features = false -``` - -## Traits - -#### Debug - -Use `#[derive(Educe)]` and `#[educe(Debug)]` to implement the `Debug` trait for a struct, enum, or union. This allows you to modify the names of your types, variants, and fields. You can also choose to ignore specific fields or set a method to replace the `Debug` trait. Additionally, you have the option to format a struct as a tuple and vice versa. - -###### Basic Usage - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Debug)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Change the Name of a Type, a Variant or a Field - -The `name` parameter can rename a type, a variant or a field. If you set it to `false`, the name can be ignored or forced to show otherwise. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug(name(Struct2)))] -struct Struct { - #[educe(Debug(name(f)))] - f1: u8 -} - -#[derive(Educe)] -#[educe(Debug(name = true))] -enum Enum { - #[educe(Debug(name = false))] - V1, - #[educe(Debug(name(V)))] - V2 { - #[educe(Debug(name(f)))] - f1: u8, - }, - #[educe(Debug(name = false))] - V3(u8), -} -# } -``` - -###### Ignore Fields - -The `ignore` parameter can ignore a specific field. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug)] -struct Struct { - #[educe(Debug(ignore))] - f1: u8 -} - -#[derive(Educe)] -#[educe(Debug)] -enum Enum { - V1, - V2 { - #[educe(Debug(ignore))] - f1: u8, - }, - V3( - #[educe(Debug(ignore))] - u8 - ), -} -# } -``` - -###### Fake Structs and Tuples - -With the `named_field` parameter, structs can be formatted as tuples and tuples can be formatted as structs. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug(named_field = false))] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Debug)] -enum Enum { - V1, - #[educe(Debug(named_field = false))] - V2 { - f1: u8, - }, - #[educe(Debug(named_field = true))] - V3( - u8, - #[educe(Debug(name(value)))] - i32 - ), -} -# } -``` - -###### Use Another Method to Handle the Formatting - -The `method` parameter can be utilized to replace the implementation of the `Debug` trait for a field, eliminating the need to implement the `Debug` trait for the type of that field. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -use std::fmt::{self, Formatter}; - -fn fmt<T>(_s: &T, f: &mut Formatter<'_>) -> fmt::Result { - f.write_str("Hi") -} - -#[derive(Educe)] -#[educe(Debug)] -enum Enum<T> { - V1, - V2 { - #[educe(Debug(method(fmt)))] - f1: u8, - }, - V3( - #[educe(Debug(method(std::fmt::UpperHex::fmt)))] - u8, - #[educe(Debug(method(fmt)))] - T - ), -} -# } -``` - -###### Generic Parameters Bound to the `Debug` Trait or Others - -Generic parameters will be automatically bound to the `Debug` trait if necessary. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -use std::fmt::{self, Formatter}; - -fn fmt<D>(_s: &D, f: &mut Formatter<'_>) -> fmt::Result { - f.write_str("Hi") -} - -#[derive(Educe)] -#[educe(Debug(bound(T: std::fmt::Debug)))] -enum Enum<T, K> { - V1, - V2 { - #[educe(Debug(method(fmt)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -In the above case, `T` is bound to the `Debug` trait, but `K` is not. - -Or, you can have `educe` replicate the behaviour of `std`'s `derive`'s, where a bound is produced for *every* generic parameter, without regard to how it's used in the structure: - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug(bound(*)))] -struct Struct<T> { - #[educe(Debug(ignore))] - f: T, -} -# } -``` - -This can be useful if you don't want to make the trait implementation part of your permanent public API. In this example, `Struct<T>` doesn't implement `Debug` unless `T` does. I.e., it has a `T: Debug` bound even though that's not needed right now. Later we might want to display `f`; we wouldn't then need to make a breaking API change by adding the bound. - -This was the behaviour of `Trait(bound)` in educe 0.4.x and earlier. - -###### Union - -A union will be formatted as a `u8` slice because we don't know its fields at runtime. The fields of a union cannot be ignored, renamed, or formatted with other methods. The implementation is **unsafe** because it may expose uninitialized memory. - -```rust -# #[cfg(feature = "Debug")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Debug(unsafe))] -union Union { - f1: u8, - f2: i32, -} -# } -``` - -#### Clone - -Use `#[derive(Educe)]` and `#[educe(Clone)]` to implement the `Clone` trait for a struct, an enum, or a union. You can set a method to replace the `Clone` trait. - -###### Basic Usage - -```rust -# #[cfg(feature = "Clone")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Clone)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Clone)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Use Another Method to Perform Cloning - -The `method` parameter can be utilized to replace the implementation of the `Clone` trait for a field, eliminating the need to implement the `Clone` trait for the type of that field. - -```rust -# #[cfg(feature = "Clone")] -# { -use educe::Educe; - -fn clone(v: &u8) -> u8 { - v + 100 -} - -trait A { - fn add(&self, rhs: u8) -> Self; -} - -fn clone2<T: A>(v: &T) -> T { - v.add(100) -} - -#[derive(Educe)] -#[educe(Clone)] -enum Enum<T: A> { - V1, - V2 { - #[educe(Clone(method(clone)))] - f1: u8, - }, - V3( - #[educe(Clone(method(clone2)))] - T - ), -} -# } -``` - -###### Generic Parameters Bound to the `Clone` Trait or Others - -Generic parameters will be automatically bound to the `Clone` trait if necessary. If the `#[educe(Copy)]` attribute exists, they will be bound to the `Copy` trait. - -```rust -# #[cfg(feature = "Clone")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Clone)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "Clone")] -# { -use educe::Educe; - -trait A { - fn add(&self, rhs: u8) -> Self; -} - -fn clone<T: A>(v: &T) -> T { - v.add(100) -} - -#[derive(Educe)] -#[educe(Clone(bound(T: std::clone::Clone)))] -enum Enum<T, K: A> { - V1, - V2 { - #[educe(Clone(method(clone)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -In the above case, `T` is bound to the `Clone` trait, but `K` is not. - -Or, you can have `educe` replicate the behaviour of `std`'s `derive`'s by using `bound(*)`. See the [`Debug`](#debug) section for more information. - -```rust -# #[cfg(feature = "Clone")] -# { -use educe::Educe; - -trait A { - fn add(&self, rhs: u8) -> Self; -} - -fn clone<T: A>(v: &T) -> T { - v.add(100) -} - -#[derive(Educe)] -#[educe(Clone(bound(*)))] -struct Struct<T: A> { - #[educe(Clone(method(clone)))] - f: T, -} -# } -``` - -###### Union - -Refer to the introduction of the `#[educe(Copy)]` attribute. - -#### Copy - -Use `#[derive(Educe)]` and `#[educe(Copy)]` to implement the `Copy` trait for a struct, an enum, or a union. - -###### Basic Usage - -```rust -# #[cfg(all(feature = "Clone", feature = "Copy"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Copy, Clone)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Copy, Clone)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Generic Parameters Bound to the `Copy` Trait or Others - -All generic parameters will be automatically bound to the `Copy` trait. - -```rust -# #[cfg(all(feature = "Clone", feature = "Copy"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Copy, Clone)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(all(feature = "Clone", feature = "Copy"))] -# { -use educe::Educe; - -trait A { - fn add(&self, rhs: u8) -> Self; -} - -fn clone<T: A>(v: &T) -> T { - v.add(100) -} - -#[derive(Educe)] -#[educe(Copy, Clone(bound(T: Copy, K: A + Copy)))] -enum Enum<T, K> { - V1, - V2 { - #[educe(Clone(method(clone)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -Note that utilizing custom cloning methods for a type that implements the `Copy` and `Clone` traits may not be entirely appropriate. - -###### Union - -The `#[educe(Copy, Clone)]` attribute can be used for a union. The fields of a union cannot be cloned with other methods. - -```rust -# #[cfg(all(feature = "Clone", feature = "Copy"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Copy, Clone)] -union Union { - f1: u8, -} -# } -``` - -#### PartialEq - -Use `#[derive(Educe)]` and `#[educe(PartialEq)]` to implement the `PartialEq` trait for a struct, enum, or union. You can also choose to ignore specific fields or set a method to replace the `PartialEq` trait. - -###### Basic Usage - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(PartialEq)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Ignore Fields - -The `ignore` parameter can ignore a specific field. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq)] -struct Struct { - #[educe(PartialEq(ignore))] - f1: u8 -} - -#[derive(Educe)] -#[educe(PartialEq)] -enum Enum { - V1, - V2 { - #[educe(PartialEq(ignore))] - f1: u8, - }, - V3( - #[educe(PartialEq(ignore))] - u8 - ), -} -# } -``` - -###### Use Another Method to Perform Comparison - -The `method` parameter can be utilized to replace the implementation of the `PartialEq` trait for a field, eliminating the need to implement the `PartialEq` trait for the type of that field. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -fn eq(a: &u8, b: &u8) -> bool { - a + 1 == *b -} - -trait A { - fn is_same(&self, other: &Self) -> bool; -} - -fn eq2<T: A>(a: &T, b: &T) -> bool { - a.is_same(b) -} - -#[derive(Educe)] -#[educe(PartialEq)] -enum Enum<T: A> { - V1, - V2 { - #[educe(PartialEq(method(eq)))] - f1: u8, - }, - V3( - #[educe(PartialEq(method(eq2)))] - T - ), -} -# } -``` - -###### Generic Parameters Bound to the `PartialEq` Trait or Others - -Generic parameters will be automatically bound to the `PartialEq` trait if necessary. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -trait A { - fn is_same(&self, other: &Self) -> bool; -} - -fn eq<T: A>(a: &T, b: &T) -> bool { - a.is_same(b) -} - -#[derive(Educe)] -#[educe(PartialEq(bound(T: std::cmp::PartialEq, K: A)))] -enum Enum<T, K> { - V1, - V2 { - #[educe(PartialEq(method(eq)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -In the above case, `T` is bound to the `PartialEq` trait, but `K` is not. - -You can have `educe` replicate the behaviour of `std`'s `derive`'s by using `bound(*)`. See the [`Debug`](#debug) section for more information. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq(bound(*)))] -struct Struct<T> { - #[educe(PartialEq(ignore))] - f: T, -} -# } -``` - -###### Union - -The `#[educe(PartialEq(unsafe))]` attribute can be used for a union. The fields of a union cannot be compared with other methods. The implementation is **unsafe** because it disregards the specific fields it utilizes. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq(unsafe))] -union Union { - f1: u8, - f2: i32 -} -# } -``` - -#### Eq - -Use `#[derive(Educe)]` and `#[educe(Eq)]` to implement the `Eq` trait for a struct, enum, or union. You can also choose to ignore specific fields or set a method to replace the `PartialEq` trait. - -###### Basic Usage - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq, Eq)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(PartialEq, Eq)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Ignore Fields - -The `ignore` parameter can ignore a specific field. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq, Eq)] -struct Struct { - #[educe(Eq(ignore))] - f1: u8 -} - -#[derive(Educe)] -#[educe(PartialEq, Eq)] -enum Enum { - V1, - V2 { - #[educe(Eq(ignore))] - f1: u8, - }, - V3( - #[educe(Eq(ignore))] - u8 - ), -} -# } -``` - -###### Use Another Method to Perform Comparison - -The `method` parameter can be utilized to replace the implementation of the `Eq` trait for a field, eliminating the need to implement the `PartialEq` trait for the type of that field. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq"))] -# { -use educe::Educe; - -fn eq(a: &u8, b: &u8) -> bool { - a + 1 == *b -} - -trait A { - fn is_same(&self, other: &Self) -> bool; -} - -fn eq2<T: A>(a: &T, b: &T) -> bool { - a.is_same(b) -} - -#[derive(Educe)] -#[educe(PartialEq, Eq)] -enum Enum<T: A> { - V1, - V2 { - #[educe(Eq(method(eq)))] - f1: u8, - }, - V3( - #[educe(Eq(method(eq2)))] - T - ), -} -# } -``` - -###### Generic Parameters Bound to the `PartialEq` Trait or Others - -Generic parameters will be automatically bound to the `PartialEq` trait if necessary. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq, Eq)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq"))] -# { -use educe::Educe; - -trait A { - fn is_same(&self, other: &Self) -> bool; -} - -fn eq<T: A>(a: &T, b: &T) -> bool { - a.is_same(b) -} - -#[derive(Educe)] -#[educe(PartialEq(bound(T: std::cmp::PartialEq, K: A)), Eq)] -enum Enum<T, K> { - V1, - V2 { - #[educe(Eq(method(eq)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -###### Union - -The `#[educe(PartialEq(unsafe), Eq)]` attribute can be used for a union. The fields of a union cannot be compared with other methods. The implementation is **unsafe** because it disregards the specific fields it utilizes. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq(unsafe), Eq)] -union Union { - f1: u8, - f2: i32 -} -# } -``` - -#### PartialOrd - -Use `#[derive(Educe)]` and `#[educe(PartialOrd)]` to implement the `PartialOrd` trait for a struct or enum. You can also choose to ignore specific fields or set a method to replace the `PartialOrd` trait. - -###### Basic Usage - -```rust -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -struct Struct { - f1: u8 -} - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Ignore Fields - -The `ignore` parameter can ignore a specific field. - -```rust -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -struct Struct { - #[educe(PartialOrd(ignore))] - f1: u8 -} - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -enum Enum { - V1, - V2 { - #[educe(PartialOrd(ignore))] - f1: u8, - }, - V3( - #[educe(PartialOrd(ignore))] - u8 - ), -} -# } -``` - -###### Use Another Method to Perform Comparison - -The `method` parameter can be utilized to replace the implementation of the `PartialOrd` trait for a field, eliminating the need to implement the `PartialOrd` trait for the type of that field. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "PartialOrd"))] -# { -use educe::Educe; - -use std::cmp::Ordering; - -fn partial_cmp(a: &u8, b: &u8) -> Option<Ordering> { - if a > b { - Some(Ordering::Less) - } else if a < b { - Some(Ordering::Greater) - } else { - Some(Ordering::Equal) - } -} - -trait A { - fn value(&self) -> u8; -} - -fn partial_cmp2<T: A>(a: &T, b: &T) -> Option<Ordering> { - partial_cmp(&a.value(), &b.value()) -} - -#[derive(Educe)] -#[educe(PartialEq, PartialOrd)] -enum Enum<T: A> { - V1, - V2 { - #[educe(PartialOrd(method(partial_cmp)))] - f1: u8, - }, - V3( - #[educe(PartialOrd(method(partial_cmp2)))] - T - ), -} -# } -``` - -###### Ranking - -Each field can add a `#[educe(PartialOrd(rank = priority_value))]` attribute, where `priority_value` is an integer value indicating its comparison precedence (lower values indicate higher priority). The default `priority_value` for a field depends on its ordinal position (lower towards the front) and starts with `isize::MIN`. - -```rust -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -struct Struct { - #[educe(PartialOrd(rank = 1))] - f1: u8, - #[educe(PartialOrd(rank = 0))] - f2: u8, -} -# } -``` - -For variants, the discriminant can be explicitly set for comparison. - -```rust,ignore -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -#[repr(u8)] -enum Enum { - Three { f1: u8 } = 3, - Two(u8) = 2, - One = 1, -} -# } -``` - -###### Generic Parameters Bound to the `PartialOrd` Trait or Others - -Generic parameters will be automatically bound to the `PartialOrd` trait if necessary. - -```rust -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -use std::cmp::Ordering; - -trait A { - fn value(&self) -> u8; -} - -fn partial_cmp<T: A>(a: &T, b: &T) -> Option<Ordering> { - a.value().partial_cmp(&b.value()) -} - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd(bound(T: std::cmp::PartialOrd, K: PartialEq + A)))] -enum Enum<T, K> { - V1, - V2 { - #[educe(PartialOrd(method(partial_cmp)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -In the above case, `T` is bound to the `PartialOrd` trait, but `K` is not. - -You can have `educe` replicate the behaviour of `std`'s `derive`'s by using `bound(*)`. See the [`Debug`](#debug) section for more information. - -```rust -# #[cfg(feature = "PartialOrd")] -# { -use educe::Educe; - -#[derive(PartialEq, Educe)] -#[educe(PartialOrd(bound(*)))] -struct Struct<T> { - #[educe(PartialOrd(ignore))] - f: T, -} -# } -``` - -###### Union - -The `#[educe(PartialEq(unsafe))]` attribute can be used for a union. The fields of a union cannot be compared with other methods. The implementation is **unsafe** because it disregards the specific fields it utilizes. - -```rust -# #[cfg(feature = "PartialEq")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq(unsafe))] -union Union { - f1: u8, - f2: i32 -} -# } -``` - -#### Ord - -Use `#[derive(Educe)]` and `#[educe(Ord)]` to implement the `Ord` trait for a struct or enum. You can also choose to ignore specific fields or set a method to replace the `Ord` trait. - -###### Basic Usage - -```rust -# #[cfg(all(feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -struct Struct { - f1: u8 -} - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Ignore Fields - -The `ignore` parameter can ignore a specific field. - -```rust -# #[cfg(all(feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -struct Struct { - #[educe(Ord(ignore))] - f1: u8 -} - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -enum Enum { - V1, - V2 { - #[educe(Ord(ignore))] - f1: u8, - }, - V3( - #[educe(Ord(ignore))] - u8 - ), -} -# } -``` - -###### Use Another Method to Perform Comparison - -The `method` parameter can be utilized to replace the implementation of the `Ord` trait for a field, eliminating the need to implement the `Ord` trait for the type of that field. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq", feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -use std::cmp::Ordering; - -fn cmp(a: &u8, b: &u8) -> Ordering { - if a > b { - Ordering::Less - } else if a < b { - Ordering::Greater - } else { - Ordering::Equal - } -} - -trait A { - fn value(&self) -> u8; -} - -fn cmp2<T: A>(a: &T, b: &T) -> Ordering { - cmp(&a.value(), &b.value()) -} - -#[derive(Educe)] -#[educe(PartialEq, Eq, PartialOrd, Ord)] -enum Enum<T: A> { - V1, - V2 { - #[educe(Ord(method(cmp)))] - f1: u8, - }, - V3( - #[educe(Ord(method(cmp2)))] - T - ), -} -# } -``` - -###### Ranking - -Each field can add a `#[educe(Ord(rank = priority_value))]` attribute, where `priority_value` is an integer value indicating its comparison precedence (lower values indicate higher priority). The default `priority_value` for a field depends on its ordinal position (lower towards the front) and starts with `isize::MIN`. - -```rust -# #[cfg(all(feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -struct Struct { - #[educe(Ord(rank = 1))] - f1: u8, - #[educe(Ord(rank = 0))] - f2: u8, -} -# } -``` - -For variants, the discriminant can be explicitly set for comparison. - -```rust,ignore -# #[cfg(all(feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -#[repr(u8)] -enum Enum { - Three { f1: u8 } = 3, - Two(u8) = 2, - One = 1, -} -# } -``` - -###### Generic Parameters Bound to the `Ord` Trait or Others - -Generic parameters will be automatically bound to the `Ord` trait if necessary. - -```rust -# #[cfg(all(feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(all(feature = "PartialOrd", feature = "Ord"))] -# { -use educe::Educe; - -use std::cmp::Ordering; - -trait A { - fn value(&self) -> u8; -} - -fn cmp<T: A>(a: &T, b: &T) -> Ordering { - a.value().cmp(&b.value()) -} - -#[derive(PartialEq, Eq, Educe)] -#[educe(PartialOrd, Ord(bound(T: std::cmp::Ord, K: std::cmp::Ord + A)))] -enum Enum<T, K> { - V1, - V2 { - #[educe(PartialOrd(method(cmp)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -#### Hash - -Use `#[derive(Educe)]` and `#[educe(Hash)]` to implement the `Hash` trait for a struct, enum, or union. You can also choose to ignore specific fields or set a method to replace the `Hash` trait. - -###### Basic Usage - -```rust -# #[cfg(feature = "Hash")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Hash)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Hash)] -enum Enum { - V1, - V2 { - f1: u8, - }, - V3(u8), -} -# } -``` - -###### Ignore Fields - -The `ignore` parameter can ignore a specific field. - -```rust -# #[cfg(feature = "Hash")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Hash)] -struct Struct { - #[educe(Hash(ignore))] - f1: u8 -} - -#[derive(Educe)] -#[educe(Hash)] -enum Enum { - V1, - V2 { - #[educe(Hash(ignore))] - f1: u8, - }, - V3( - #[educe(Hash(ignore))] - u8 - ), -} -# } -``` - -###### Use Another Method for Hashing - -The `method` parameter can be utilized to replace the implementation of the `Hash` trait for a field, eliminating the need to implement the `Hash` trait for the type of that field. - -```rust -# #[cfg(feature = "Hash")] -# { -use educe::Educe; - -use std::hash::{Hash, Hasher}; - -fn hash<H: Hasher>(_s: &u8, state: &mut H) { - Hash::hash(&100, state) -} - -fn hash2<H: Hasher, T>(_s: &T, state: &mut H) { - Hash::hash(&100, state) -} - -#[derive(Educe)] -#[educe(Hash)] -enum Enum<T> { - V1, - V2 { - #[educe(Hash(method(hash)))] - f1: u8, - }, - V3( - #[educe(Hash(method(hash2)))] - T - ), -} -# } -``` - -###### Generic Parameters Bound to the `Hash` Trait or Others - -Generic parameters will be automatically bound to the `Hash` trait if necessary. - -```rust -# #[cfg(feature = "Hash")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Hash)] -enum Enum<T, K> { - V1, - V2 { - f1: K, - }, - V3( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "Hash")] -# { -use educe::Educe; - -use std::hash::{Hash, Hasher}; - -trait A { - fn value(&self) -> u8; -} - -fn hash<H: Hasher, T: A>(s: &T, state: &mut H) { - Hash::hash(&s.value(), state) -} - -#[derive(Educe)] -#[educe(Hash(bound(T: std::hash::Hash, K: A)))] -enum Enum<T, K> { - V1, - V2 { - #[educe(Hash(method(hash)))] - f1: K, - }, - V3( - T - ), -} -# } -``` - -In the above case, `T` is bound to the `Hash` trait, but `K` is not. - -You can have `educe` replicate the behaviour of `std`'s `derive`'s by using `bound(*)`. See the [`Debug`](#debug) section for more information. - -```rust -# #[cfg(feature = "Hash")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Hash(bound(*)))] -struct Struct<T> { - #[educe(Hash(ignore))] - f: T, -} -# } -``` - -###### Union - -The `#[educe(PartialEq(unsafe), Eq, Hash(unsafe))]` attribute can be used for a union. The fields of a union cannot be hashed with other methods. The implementation is **unsafe** because it disregards the specific fields it utilizes. - -```rust -# #[cfg(all(feature = "PartialEq", feature = "Eq", feature = "Hash"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(PartialEq(unsafe), Eq, Hash(unsafe))] -union Union { - f1: u8, - f2: i32 -} -# } -``` - -#### Default - -Use `#[derive(Educe)]` and `#[educe(Default)]` to implement the `Default` trait for a struct, enum, or union. You can also choose to ignore specific fields or set a method to replace the `Hash` trait. - -###### Basic Usage - -For enums and unions, it is necessary to designate a default variant (for enums) and a default field (for unions) unless the enum has only one variant or the union has only one field. - -```rust -# #[cfg(feature = "Default")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Default)] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Default)] -enum Enum { - V1, - #[educe(Default)] - V2 { - f1: u8, - }, - V3(u8), -} - -#[derive(Educe)] -#[educe(Default)] -union Union { - f1: u8, - #[educe(Default)] - f2: f64, -} -# } -``` - -###### The Default Value for the Entire Type - -```rust -# #[cfg(feature = "Default")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Default(expression = Struct { f1: 1 }))] -struct Struct { - f1: u8 -} - -#[derive(Educe)] -#[educe(Default(expression = Enum::Struct { f1: 1 }))] -enum Enum { - Unit, - Struct { - f1: u8 - }, - Tuple(u8), -} - -#[derive(Educe)] -#[educe(Default(expression = Union { f1: 1 }))] -union Union { - f1: u8, - f2: f64, -} -# } -``` - -You may need to activate the `full` feature to enable support for advanced expressions. - -###### The Default Values for Specific Fields - -```rust -# #[cfg(feature = "Default")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Default)] -struct Struct { - #[educe(Default = 1)] - f1: u8, - #[educe(Default = 11111111111111111111111111111)] - f2: i128, - #[educe(Default = 1.1)] - f3: f64, - #[educe(Default = true)] - f4: bool, - #[educe(Default = "Hi")] - f5: &'static str, - #[educe(Default = "Hello")] - f6: String, - #[educe(Default = 'M')] - f7: char, -} - -#[derive(Educe)] -#[educe(Default)] -enum Enum { - Unit, - #[educe(Default)] - Tuple( - #[educe(Default(expression = 0 + 1))] - u8, - #[educe(Default(expression = -11111111111111111111111111111 * -1))] - i128, - #[educe(Default(expression = 1.0 + 0.1))] - f64, - #[educe(Default(expression = !false))] - bool, - #[educe(Default(expression = "Hi"))] - &'static str, - #[educe(Default(expression = String::from("Hello")))] - String, - #[educe(Default(expression = 'M'))] - char, - ), -} - -#[derive(Educe)] -#[educe(Default)] -union Union { - f1: u8, - f2: i128, - f3: f64, - f4: bool, - #[educe(Default = "Hi")] - f5: &'static str, - f6: char, -} -# } -``` - -###### Generic Parameters Bound to the `Default` Trait or Others - -Generic parameters will be automatically bound to the `Default` trait if necessary. - -```rust -# #[cfg(feature = "Default")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Default)] -enum Enum<T> { - Unit, - #[educe(Default)] - Struct { - f1: T - }, - Tuple(T), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "Default")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Default(bound(T: std::default::Default)))] -enum Enum<T> { - Unit, - #[educe(Default)] - Struct { - f1: T - }, - Tuple(T), -} -# } -``` - -###### The `new` Associated Function - -With the `#[educe(Default(new))]` attribute, your type will include an additional associated function called `new`. This function can be utilized to invoke the `default` method of the `Default` trait. - -```rust -# #[cfg(feature = "Default")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Default(new))] -struct Struct { - f1: u8 -} -# } -``` - -#### Deref - -Use `#[derive(Educe)]` and `#[educe(Deref)]` to implement the `Deref` trait for a struct or enum. - -###### Basic Usage - -You must designate a field as the default for obtaining an immutable reference unless the number of fields is exactly one. - -```rust -# #[cfg(feature = "Deref")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Deref)] -struct Struct { - f1: u8, - #[educe(Deref)] - f2: u8, -} - -#[derive(Educe)] -#[educe(Deref)] -enum Enum { - Struct { - f1: u8 - }, - Struct2 { - f1: u8, - #[educe(Deref)] - f2: u8, - }, - Tuple(u8), - Tuple2( - u8, - #[educe(Deref)] - u8 - ), -} -# } -``` - -#### DerefMut - -Use `#[derive(Educe)]` and `#[educe(DerefMut)]` to implement the `DerefMut` trait for a struct or enum. - -###### Basic Usage - -You must designate a field as the default for obtaining an mutable reference unless the number of fields is exactly one. - -```rust -# #[cfg(all(feature = "Deref", feature = "DerefMut"))] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Deref, DerefMut)] -struct Struct { - f1: u8, - #[educe(Deref, DerefMut)] - f2: u8, -} - -#[derive(Educe)] -#[educe(Deref, DerefMut)] -enum Enum { - Struct { - f1: u8 - }, - Struct2 { - f1: u8, - #[educe(Deref, DerefMut)] - f2: u8, - }, - Tuple(u8), - Tuple2( - #[educe(DerefMut)] - u8, - #[educe(Deref)] - u8 - ), -} -# } -``` - -The mutable dereferencing fields do not need to be the same as the immutable dereferencing fields, but their types must be consistent. - -#### Into - -Use `#[derive(Educe)]` and `#[educe(Into(type))]` to implement the `Into<type>` trait for a struct or enum. - -###### Basic Usage - -You need to designate a field as the default for `Into<type>` conversion unless the number of fields is exactly one. If you don't, educe will automatically try to find a proper one. - -```rust -# #[cfg(feature = "Into")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Into(u8), Into(u16))] -struct Struct { - f1: u8, - f2: u16, -} - -#[derive(Educe)] -#[educe(Into(u8))] -enum Enum { - V1 { - f1: u8, - #[educe(Into(u8))] - f2: u8, - }, - V2 ( - u8 - ), -} -# } -``` - -###### Use Another Method to Perform Into Conversion - -The `method` parameter can be utilized to replace the implementation of the `Into` trait for a field, eliminating the need to implement the `Into` trait for the type of that field. - -```rust -# #[cfg(feature = "Into")] -# { -use educe::Educe; - -fn into(v: u16) -> u8 { - v as u8 -} - -#[derive(Educe)] -#[educe(Into(u8))] -enum Enum { - V1 { - #[educe(Into(u8, method(into)))] - f1: u16, - }, - V2 ( - u8 - ), -} -# } -``` - -###### Generic Parameters Bound to the `Into` Trait or Others - -Generic parameters will be automatically bound to the `Into<type>` trait if necessary. - -```rust -# #[cfg(feature = "Into")] -# { -use educe::Educe; - -#[derive(Educe)] -#[educe(Into(u8))] -enum Enum<T, K> { - V1 { - f1: K, - }, - V2 ( - T - ), -} -# } -``` - -Or you can set the where predicates by yourself. - -```rust -# #[cfg(feature = "Into")] -# { -use educe::Educe; - -fn into<T>(_v: T) -> u8 { - 0 -} - -#[derive(Educe)] -#[educe(Into(u8, bound(K: Into<u8>)))] -enum Enum<T, K> { - V1 { - f1: K, - }, - V2 ( - #[educe(Into(u8, method(into)))] - T - ), -} -# } -``` - -*/ - -#![cfg_attr(docsrs, feature(doc_auto_cfg))] - -mod common; -#[allow(dead_code)] -mod panic; -mod supported_traits; -mod trait_handlers; - -use std::collections::HashMap; - -use proc_macro::TokenStream; -use supported_traits::Trait; -use syn::{ - parse::{Parse, ParseStream}, - parse_macro_input, - punctuated::Punctuated, - DeriveInput, Meta, Token, -}; -#[allow(unused)] -use trait_handlers::{TraitHandler, TraitHandlerMultiple}; - -fn derive_input_handler(ast: DeriveInput) -> syn::Result<proc_macro2::TokenStream> { - let mut token_stream = proc_macro2::TokenStream::new(); - let mut trait_meta_map: HashMap<Trait, Vec<Meta>> = HashMap::new(); - - for attr in ast.attrs.iter() { - let path = attr.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attr.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if let Some(v_meta) = trait_meta_map.get_mut(&t) { - // except for those traits containing generics types - - #[cfg(feature = "Into")] - if t == Trait::Into { - v_meta.push(meta); - - continue; - } - - // avoid unused warnings - let _ = v_meta; - - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - trait_meta_map.insert(t, vec![meta]); - } - } else { - return Err(panic::educe_format_incorrect(path.get_ident().unwrap())); - } - } - } - - let traits: Vec<Trait> = trait_meta_map.keys().copied().collect(); - - #[cfg(feature = "Debug")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Debug) { - trait_handlers::debug::DebugHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Clone")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Clone) { - trait_handlers::clone::CloneHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Copy")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Copy) { - trait_handlers::copy::CopyHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "PartialEq")] - { - if let Some(meta) = trait_meta_map.get(&Trait::PartialEq) { - trait_handlers::partial_eq::PartialEqHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Eq")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Eq) { - trait_handlers::eq::EqHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "PartialOrd")] - { - if let Some(meta) = trait_meta_map.get(&Trait::PartialOrd) { - trait_handlers::partial_ord::PartialOrdHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Ord")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Ord) { - trait_handlers::ord::OrdHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Hash")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Hash) { - trait_handlers::hash::HashHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Default")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Default) { - trait_handlers::default::DefaultHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Deref")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Deref) { - trait_handlers::deref::DerefHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "DerefMut")] - { - if let Some(meta) = trait_meta_map.get(&Trait::DerefMut) { - trait_handlers::deref_mut::DerefMutHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - &meta[0], - )?; - } - } - - #[cfg(feature = "Into")] - { - if let Some(meta) = trait_meta_map.get(&Trait::Into) { - trait_handlers::into::IntoHandler::trait_meta_handler( - &ast, - &mut token_stream, - &traits, - meta, - )?; - } - } - - if trait_meta_map.contains_key(&Trait::_Nothing) { - // avoid unused warnings - let _ = * - let _ = &mut token_stream; - let _ = traits; - unreachable!(); - } - - if token_stream.is_empty() { - return Err(panic::derive_attribute_not_set_up_yet()); - } - - Ok(token_stream) -} - -#[proc_macro_derive(Educe, attributes(educe))] -pub fn educe_derive(input: TokenStream) -> TokenStream { - struct MyDeriveInput(proc_macro2::TokenStream); - - impl Parse for MyDeriveInput { - #[inline] - fn parse(input: ParseStream) -> syn::Result<Self> { - let token_stream = derive_input_handler(input.parse::<DeriveInput>()?)?; - - Ok(Self(token_stream)) - } - } - - // Parse the token stream - let derive_input = parse_macro_input!(input as MyDeriveInput); - - derive_input.0.into() -} diff --git a/vendor/educe/src/panic.rs b/vendor/educe/src/panic.rs deleted file mode 100644 index eb059ff4..00000000 --- a/vendor/educe/src/panic.rs +++ /dev/null @@ -1,130 +0,0 @@ -use core::fmt::{self, Display, Formatter}; - -use proc_macro2::Span; -use syn::{spanned::Spanned, Ident, Path, Variant}; - -use crate::{common::path::path_to_string, Trait}; - -struct DisplayStringSlice<'a>(&'a [&'static str]); - -impl<'a> Display for DisplayStringSlice<'a> { - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - if !self.0.is_empty() { - f.write_str(", which should be reformatted as follows:")?; - - for &s in self.0 { - f.write_str("\n ")?; - f.write_str(s)?; - } - } - - Ok(()) - } -} - -struct DisplayTraits; - -impl Display for DisplayTraits { - #[inline] - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - for t in &Trait::VARIANTS[..Trait::VARIANTS.len() - 1] { - f.write_str("\n ")?; - f.write_fmt(format_args!("{t:?}"))?; - } - - Ok(()) - } -} - -#[inline] -pub(crate) fn derive_attribute_not_set_up_yet() -> syn::Error { - syn::Error::new( - Span::call_site(), - "you are using `Educe` in the `derive` attribute, but it has not been set up yet", - ) -} - -#[inline] -pub(crate) fn attribute_incorrect_place(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), format!("the `{name}` attribute cannot be placed here")) -} - -#[inline] -pub(crate) fn attribute_incorrect_format_with_span( - name: &Ident, - span: Span, - correct_usage: &[&'static str], -) -> syn::Error { - if correct_usage.is_empty() { - attribute_incorrect_place(name) - } else { - syn::Error::new( - span, - format!( - "you are using an incorrect format of the `{name}` attribute{}", - DisplayStringSlice(correct_usage) - ), - ) - } -} - -#[inline] -pub(crate) fn attribute_incorrect_format( - name: &Ident, - correct_usage: &[&'static str], -) -> syn::Error { - attribute_incorrect_format_with_span(name, name.span(), correct_usage) -} - -#[inline] -pub(crate) fn parameter_reset(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), format!("you are trying to reset the `{name}` parameter")) -} - -#[inline] -pub(crate) fn educe_format_incorrect(name: &Ident) -> syn::Error { - attribute_incorrect_format(name, &[stringify!(#[educe(Trait1, Trait2, ..., TraitN)])]) -} - -#[inline] -pub(crate) fn unsupported_trait(name: &Path) -> syn::Error { - let span = name.span(); - - match name.get_ident() { - Some(name) => syn::Error::new( - span, - format!("unsupported trait `{name}`, available traits:{DisplayTraits}"), - ), - None => { - let name = path_to_string(name); - - syn::Error::new( - span, - format!("unsupported trait `{name}`, available traits:{DisplayTraits}"), - ) - }, - } -} - -#[inline] -pub(crate) fn reuse_a_trait(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), format!("the trait `{name}` is used repeatedly")) -} - -#[inline] -pub(crate) fn trait_not_used(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), format!("the trait `{name}` is not used")) -} - -#[inline] -pub(crate) fn trait_not_support_union(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), format!("the trait `{name}` does not support to a union")) -} - -#[inline] -pub(crate) fn trait_not_support_unit_variant(name: &Ident, variant: &Variant) -> syn::Error { - syn::Error::new( - variant.span(), - format!("the trait `{name}` cannot be implemented for an enum which has unit variants"), - ) -} diff --git a/vendor/educe/src/supported_traits.rs b/vendor/educe/src/supported_traits.rs deleted file mode 100644 index 50f7f302..00000000 --- a/vendor/educe/src/supported_traits.rs +++ /dev/null @@ -1,88 +0,0 @@ -#[cfg(not(any( - feature = "Debug", - feature = "Clone", - feature = "Copy", - feature = "PartialEq", - feature = "Eq", - feature = "PartialOrd", - feature = "Ord", - feature = "Hash", - feature = "Default", - feature = "Deref", - feature = "DerefMut", - feature = "Into", -)))] -compile_error!("at least one of the trait features must be enabled"); - -use enum_ordinalize::Ordinalize; -use syn::Path; - -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Ordinalize)] -#[ordinalize(impl_trait = false)] -#[ordinalize(variants(pub(crate) const VARIANTS))] -pub(crate) enum Trait { - #[cfg(feature = "Debug")] - Debug, - #[cfg(feature = "Clone")] - Clone, - #[cfg(feature = "Copy")] - Copy, - #[cfg(feature = "PartialEq")] - PartialEq, - #[cfg(feature = "Eq")] - Eq, - #[cfg(feature = "PartialOrd")] - PartialOrd, - #[cfg(feature = "Ord")] - Ord, - #[cfg(feature = "Hash")] - Hash, - #[cfg(feature = "Default")] - Default, - #[cfg(feature = "Deref")] - Deref, - #[cfg(feature = "DerefMut")] - DerefMut, - #[cfg(feature = "Into")] - Into, - - _Nothing, -} - -impl Trait { - #[inline] - pub(crate) fn from_path(path: &Path) -> Option<Self> { - let ident_string = match path.get_ident() { - Some(ident) => ident.to_string(), - None => return None, - }; - - match ident_string.as_str() { - #[cfg(feature = "Debug")] - "Debug" => Some(Self::Debug), - #[cfg(feature = "Clone")] - "Clone" => Some(Self::Clone), - #[cfg(feature = "Copy")] - "Copy" => Some(Self::Copy), - #[cfg(feature = "PartialEq")] - "PartialEq" => Some(Self::PartialEq), - #[cfg(feature = "Eq")] - "Eq" => Some(Self::Eq), - #[cfg(feature = "PartialOrd")] - "PartialOrd" => Some(Self::PartialOrd), - #[cfg(feature = "Ord")] - "Ord" => Some(Self::Ord), - #[cfg(feature = "Hash")] - "Hash" => Some(Self::Hash), - #[cfg(feature = "Default")] - "Default" => Some(Self::Default), - #[cfg(feature = "Deref")] - "Deref" => Some(Self::Deref), - #[cfg(feature = "DerefMut")] - "DerefMut" => Some(Self::DerefMut), - #[cfg(feature = "Into")] - "Into" => Some(Self::Into), - _ => None, - } - } -} diff --git a/vendor/educe/src/trait_handlers/clone/clone_enum.rs b/vendor/educe/src/trait_handlers/clone/clone_enum.rs deleted file mode 100644 index 991243ac..00000000 --- a/vendor/educe/src/trait_handlers/clone/clone_enum.rs +++ /dev/null @@ -1,272 +0,0 @@ -use quote::{format_ident, quote}; -use syn::{punctuated::Punctuated, Data, DeriveInput, Field, Fields, Meta, Type, Variant}; - -use super::models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}; -use crate::{ - common::where_predicates_bool::WherePredicates, supported_traits::Trait, TraitHandler, -}; - -pub(crate) struct CloneEnumHandler; - -impl TraitHandler for CloneEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_clone_meta(meta)?; - - let mut bound: WherePredicates = Punctuated::new(); - - let mut clone_token_stream = proc_macro2::TokenStream::new(); - let mut clone_from_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - type Variants<'a> = Vec<(&'a Variant, Vec<(&'a Field, FieldAttribute)>)>; - - let mut variants: Variants = Vec::new(); - - #[cfg(feature = "Copy")] - let mut has_custom_clone_method = false; - - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, enable_bound: false - } - .build_from_attributes(&variant.attrs, traits)?; - - let mut variant_fields: Vec<(&Field, FieldAttribute)> = Vec::new(); - - for field in variant.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_method: true - } - .build_from_attributes(&field.attrs, traits)?; - - #[cfg(feature = "Copy")] - if field_attribute.method.is_some() { - has_custom_clone_method = true; - } - - variant_fields.push((field, field_attribute)); - } - - variants.push((variant, variant_fields)); - } - - #[cfg(feature = "Copy")] - let contains_copy = !has_custom_clone_method && traits.contains(&Trait::Copy); - - #[cfg(not(feature = "Copy"))] - let contains_copy = false; - - if contains_copy { - clone_token_stream.extend(quote!(*self)); - } - - let mut clone_types: Vec<&Type> = Vec::new(); - - if variants.is_empty() { - if !contains_copy { - clone_token_stream.extend(quote!(unreachable!())); - clone_from_token_stream.extend(quote!(let _ = source;)); - } - } else { - let mut clone_variants_token_stream = proc_macro2::TokenStream::new(); - let mut clone_from_variants_token_stream = proc_macro2::TokenStream::new(); - - for (variant, variant_fields) in variants { - let variant_ident = &variant.ident; - - match &variant.fields { - Fields::Unit => { - clone_variants_token_stream.extend(quote! { - Self::#variant_ident => Self::#variant_ident, - }); - clone_from_variants_token_stream.extend(quote! { - Self::#variant_ident => { - if let Self::#variant_ident = source { - // same - } else { - *self = ::core::clone::Clone::clone(source); - } - }, - }); - }, - Fields::Named(_) => { - let mut pattern_src_token_stream = proc_macro2::TokenStream::new(); - let mut pattern_dst_token_stream = proc_macro2::TokenStream::new(); - let mut cl_fields_token_stream = proc_macro2::TokenStream::new(); - let mut cf_body_token_stream = proc_macro2::TokenStream::new(); - - for (field, field_attribute) in variant_fields { - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_src = format_ident!("_s_{}", field_name_real); - let field_name_dst = format_ident!("_d_{}", field_name_real); - - pattern_src_token_stream - .extend(quote!(#field_name_real: #field_name_src,)); - pattern_dst_token_stream - .extend(quote!(#field_name_real: #field_name_dst,)); - - if let Some(clone) = field_attribute.method.as_ref() { - cl_fields_token_stream.extend(quote! { - #field_name_real: #clone(#field_name_src), - }); - cf_body_token_stream.extend( - quote!(*#field_name_dst = #clone(#field_name_src);), - ); - } else { - clone_types.push(&field.ty); - - cl_fields_token_stream.extend(quote! { - #field_name_real: ::core::clone::Clone::clone(#field_name_src), - }); - cf_body_token_stream.extend( - quote!( ::core::clone::Clone::clone_from(#field_name_dst, #field_name_src); ), - ); - } - } - - clone_variants_token_stream.extend(quote! { - Self::#variant_ident { #pattern_src_token_stream } => Self::#variant_ident { #cl_fields_token_stream }, - }); - - clone_from_variants_token_stream.extend(quote! { - Self::#variant_ident { #pattern_dst_token_stream } => { - if let Self::#variant_ident { #pattern_src_token_stream } = source { - #cf_body_token_stream - } else { - *self = ::core::clone::Clone::clone(source); - } - }, - }); - }, - Fields::Unnamed(_) => { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut pattern2_token_stream = proc_macro2::TokenStream::new(); - let mut fields_token_stream = proc_macro2::TokenStream::new(); - let mut body_token_stream = proc_macro2::TokenStream::new(); - - for (index, (field, field_attribute)) in - variant_fields.into_iter().enumerate() - { - let field_name_src = format_ident!("_{}", index); - - pattern_token_stream.extend(quote!(#field_name_src,)); - - let field_name_dst = format_ident!("_{}", field_name_src); - - pattern2_token_stream.extend(quote!(#field_name_dst,)); - - if let Some(clone) = field_attribute.method.as_ref() { - fields_token_stream.extend(quote! (#clone(#field_name_src),)); - body_token_stream.extend( - quote!(*#field_name_src = #clone(#field_name_dst);), - ); - } else { - clone_types.push(&field.ty); - - fields_token_stream.extend( - quote! ( ::core::clone::Clone::clone(#field_name_src), ), - ); - body_token_stream.extend( - quote!( ::core::clone::Clone::clone_from(#field_name_src, #field_name_dst); ), - ); - } - } - - clone_variants_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => Self::#variant_ident ( #fields_token_stream ), - }); - - clone_from_variants_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => { - if let Self::#variant_ident ( #pattern2_token_stream ) = source { - #body_token_stream - } else { - *self = ::core::clone::Clone::clone(source); - } - }, - }); - }, - } - } - - if !contains_copy { - clone_token_stream.extend(quote! { - match self { - #clone_variants_token_stream - } - }); - - clone_from_token_stream.extend(quote! { - match self { - #clone_from_variants_token_stream - } - }); - } - } - - bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(if contains_copy { - quote!(::core::marker::Copy) - } else { - quote!(::core::clone::Clone) - }) - .unwrap(), - &clone_types, - &[], - ); - } - - let clone_from_fn_token_stream = if clone_from_token_stream.is_empty() { - None - } else { - Some(quote! { - #[inline] - fn clone_from(&mut self, source: &Self) { - #clone_from_token_stream - } - }) - }; - - let ident = &ast.ident; - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::clone::Clone for #ident #ty_generics #where_clause { - #[inline] - fn clone(&self) -> Self { - #clone_token_stream - } - - #clone_from_fn_token_stream - } - }); - - #[cfg(feature = "Copy")] - if traits.contains(&Trait::Copy) { - token_stream.extend(quote! { - impl #impl_generics ::core::marker::Copy for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/clone/clone_struct.rs b/vendor/educe/src/trait_handlers/clone/clone_struct.rs deleted file mode 100644 index 73aa8faa..00000000 --- a/vendor/educe/src/trait_handlers/clone/clone_struct.rs +++ /dev/null @@ -1,195 +0,0 @@ -use quote::quote; -use syn::{punctuated::Punctuated, Data, DeriveInput, Field, Fields, Index, Meta, Type}; - -use super::models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}; -use crate::{ - common::where_predicates_bool::WherePredicates, supported_traits::Trait, TraitHandler, -}; - -pub(crate) struct CloneStructHandler; - -impl TraitHandler for CloneStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_clone_meta(meta)?; - - let mut bound: WherePredicates = Punctuated::new(); - - let mut clone_token_stream = proc_macro2::TokenStream::new(); - let mut clone_from_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - let mut fields: Vec<(&Field, FieldAttribute)> = Vec::new(); - - #[cfg(feature = "Copy")] - let contains_copy = traits.contains(&Trait::Copy); - - #[cfg(not(feature = "Copy"))] - let contains_copy = false; - - if contains_copy { - clone_token_stream.extend(quote!(*self)); - } - - for field in data.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_method: !contains_copy - } - .build_from_attributes(&field.attrs, traits)?; - - fields.push((field, field_attribute)); - } - - let mut clone_types: Vec<&Type> = Vec::new(); - - match &data.fields { - Fields::Unit => { - if !contains_copy { - clone_token_stream.extend(quote!(Self)); - clone_from_token_stream.extend(quote!(let _ = source;)); - } - }, - Fields::Named(_) => { - let mut fields_token_stream = proc_macro2::TokenStream::new(); - let mut clone_from_body_token_stream = proc_macro2::TokenStream::new(); - - if fields.is_empty() { - clone_from_body_token_stream.extend(quote!(let _ = source;)); - } else { - for (field, field_attribute) in fields { - let field_name = field.ident.as_ref().unwrap(); - - if let Some(clone) = field_attribute.method.as_ref() { - fields_token_stream.extend(quote! { - #field_name: #clone(&self.#field_name), - }); - - clone_from_body_token_stream.extend( - quote!(self.#field_name = #clone(&source.#field_name);), - ); - } else { - clone_types.push(&field.ty); - - fields_token_stream.extend(quote! { - #field_name: ::core::clone::Clone::clone(&self.#field_name), - }); - - clone_from_body_token_stream.extend( - quote!( ::core::clone::Clone::clone_from(&mut self.#field_name, &source.#field_name); ), - ); - } - } - } - - if !contains_copy { - clone_token_stream.extend(quote! { - Self { - #fields_token_stream - } - }); - - clone_from_token_stream.extend(clone_from_body_token_stream); - } - }, - Fields::Unnamed(_) => { - let mut fields_token_stream = proc_macro2::TokenStream::new(); - let mut clone_from_body_token_stream = proc_macro2::TokenStream::new(); - - if fields.is_empty() { - clone_from_body_token_stream.extend(quote!(let _ = source;)); - } else { - for (index, (field, field_attribute)) in fields.into_iter().enumerate() { - let field_name = Index::from(index); - - if let Some(clone) = field_attribute.method.as_ref() { - fields_token_stream.extend(quote!(#clone(&self.#field_name),)); - - clone_from_body_token_stream.extend( - quote!(self.#field_name = #clone(&source.#field_name);), - ); - } else { - clone_types.push(&field.ty); - - fields_token_stream.extend( - quote! ( ::core::clone::Clone::clone(&self.#field_name), ), - ); - - clone_from_body_token_stream.extend( - quote!( ::core::clone::Clone::clone_from(&mut self.#field_name, &source.#field_name); ), - ); - } - } - } - - if !contains_copy { - clone_token_stream.extend(quote!(Self ( #fields_token_stream ))); - clone_from_token_stream.extend(clone_from_body_token_stream); - } - }, - } - - bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(if contains_copy { - quote!(::core::marker::Copy) - } else { - quote!(::core::clone::Clone) - }) - .unwrap(), - &clone_types, - &[], - ); - } - - let clone_from_fn_token_stream = if clone_from_token_stream.is_empty() { - None - } else { - Some(quote! { - #[inline] - fn clone_from(&mut self, source: &Self) { - #clone_from_token_stream - } - }) - }; - - let ident = &ast.ident; - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::clone::Clone for #ident #ty_generics #where_clause { - #[inline] - fn clone(&self) -> Self { - #clone_token_stream - } - - #clone_from_fn_token_stream - } - }); - - #[cfg(feature = "Copy")] - if traits.contains(&Trait::Copy) { - token_stream.extend(quote! { - impl #impl_generics ::core::marker::Copy for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/clone/clone_union.rs b/vendor/educe/src/trait_handlers/clone/clone_union.rs deleted file mode 100644 index dc3c729a..00000000 --- a/vendor/educe/src/trait_handlers/clone/clone_union.rs +++ /dev/null @@ -1,73 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::supported_traits::Trait; - -pub(crate) struct CloneUnionHandler; - -impl TraitHandler for CloneUnionHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_clone_meta(meta)?; - - let mut field_types = vec![]; - - if let Data::Union(data) = &ast.data { - for field in data.fields.named.iter() { - field_types.push(&field.ty); - let _ = FieldAttributeBuilder { - enable_method: false - } - .build_from_attributes(&field.attrs, traits)?; - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::marker::Copy)).unwrap(), - &field_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::clone::Clone for #ident #ty_generics #where_clause { - #[inline] - fn clone(&self) -> Self { - *self - } - } - }); - - #[cfg(feature = "Copy")] - if traits.contains(&Trait::Copy) { - token_stream.extend(quote! { - impl #impl_generics ::core::marker::Copy for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/clone/mod.rs b/vendor/educe/src/trait_handlers/clone/mod.rs deleted file mode 100644 index 8c8a929f..00000000 --- a/vendor/educe/src/trait_handlers/clone/mod.rs +++ /dev/null @@ -1,36 +0,0 @@ -mod clone_enum; -mod clone_struct; -mod clone_union; -mod models; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct CloneHandler; - -impl TraitHandler for CloneHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => clone_struct::CloneStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => { - clone_enum::CloneEnumHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Union(_) => { - clone_union::CloneUnionHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - } - } -} diff --git a/vendor/educe/src/trait_handlers/clone/models/field_attribute.rs b/vendor/educe/src/trait_handlers/clone/models/field_attribute.rs deleted file mode 100644 index 63c7a9c7..00000000 --- a/vendor/educe/src/trait_handlers/clone/models/field_attribute.rs +++ /dev/null @@ -1,125 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Path, Token}; - -use crate::{common::path::meta_2_path, panic, supported_traits::Trait}; - -pub(crate) struct FieldAttribute { - pub(crate) method: Option<Path>, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_method: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_clone_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Clone")); - - let mut method = None; - - let correct_usage_for_clone_attribute = { - let mut usage = vec![]; - - if self.enable_method { - usage.push(stringify!(#[educe(Clone(method(path_to_method)))])); - } - - usage - }; - - match meta { - Meta::Path(_) | Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_clone_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut method_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "method" { - if !self.enable_method { - return Ok(false); - } - - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_clone_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - method, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Clone { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_clone_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - method: None - })) - } -} diff --git a/vendor/educe/src/trait_handlers/clone/models/mod.rs b/vendor/educe/src/trait_handlers/clone/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/clone/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/clone/models/type_attribute.rs b/vendor/educe/src/trait_handlers/clone/models/type_attribute.rs deleted file mode 100644 index f657bbfa..00000000 --- a/vendor/educe/src/trait_handlers/clone/models/type_attribute.rs +++ /dev/null @@ -1,140 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{common::bound::Bound, panic, Trait}; - -pub(crate) struct TypeAttribute { - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_clone_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Clone")); - - let mut bound = Bound::Auto; - - let correct_usage_for_clone_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Clone)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Clone(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Clone(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_clone_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_clone_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_clone_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Clone { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_clone_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/copy/mod.rs b/vendor/educe/src/trait_handlers/copy/mod.rs deleted file mode 100644 index e1ce4016..00000000 --- a/vendor/educe/src/trait_handlers/copy/mod.rs +++ /dev/null @@ -1,94 +0,0 @@ -mod models; - -use models::{FieldAttributeBuilder, TypeAttributeBuilder}; -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct CopyHandler; - -impl TraitHandler for CopyHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - #[cfg(feature = "Clone")] - let contains_clone = traits.contains(&Trait::Clone); - - #[cfg(not(feature = "Clone"))] - let contains_clone = false; - - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_bound: !contains_clone, - } - .build_from_copy_meta(meta)?; - - let mut field_types = vec![]; - - // if `contains_clone` is true, the implementation is handled by the `Clone` attribute, and field attributes is also handled by the `Clone` attribute - if !contains_clone { - match &ast.data { - Data::Struct(data) => { - for field in data.fields.iter() { - field_types.push(&field.ty); - let _ = - FieldAttributeBuilder.build_from_attributes(&field.attrs, traits)?; - } - }, - Data::Enum(data) => { - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, enable_bound: false - } - .build_from_attributes(&variant.attrs, traits)?; - - for field in variant.fields.iter() { - field_types.push(&field.ty); - let _ = FieldAttributeBuilder - .build_from_attributes(&field.attrs, traits)?; - } - } - }, - Data::Union(data) => { - for field in data.fields.named.iter() { - field_types.push(&field.ty); - let _ = - FieldAttributeBuilder.build_from_attributes(&field.attrs, traits)?; - } - }, - } - - let ident = &ast.ident; - - let bound = - type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::marker::Copy)).unwrap(), - &field_types, - &[quote! {::core::clone::Clone}], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::marker::Copy for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/copy/models/field_attribute.rs b/vendor/educe/src/trait_handlers/copy/models/field_attribute.rs deleted file mode 100644 index e03c02d7..00000000 --- a/vendor/educe/src/trait_handlers/copy/models/field_attribute.rs +++ /dev/null @@ -1,57 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{panic, supported_traits::Trait}; - -pub(crate) struct FieldAttribute; - -pub(crate) struct FieldAttributeBuilder; - -impl FieldAttributeBuilder { - pub(crate) fn build_from_copy_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Copy")); - - return Err(panic::attribute_incorrect_place(meta.path().get_ident().unwrap())); - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Copy { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_copy_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute)) - } -} diff --git a/vendor/educe/src/trait_handlers/copy/models/mod.rs b/vendor/educe/src/trait_handlers/copy/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/copy/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/copy/models/type_attribute.rs b/vendor/educe/src/trait_handlers/copy/models/type_attribute.rs deleted file mode 100644 index 457acef7..00000000 --- a/vendor/educe/src/trait_handlers/copy/models/type_attribute.rs +++ /dev/null @@ -1,140 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{common::bound::Bound, panic, Trait}; - -pub(crate) struct TypeAttribute { - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_copy_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Copy")); - - let mut bound = Bound::Auto; - - let correct_usage_for_copy_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Copy)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Copy(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Copy(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_copy_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_copy_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_copy_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Copy { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_copy_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/debug/common.rs b/vendor/educe/src/trait_handlers/debug/common.rs deleted file mode 100644 index e2c59a9d..00000000 --- a/vendor/educe/src/trait_handlers/debug/common.rs +++ /dev/null @@ -1,55 +0,0 @@ -use quote::quote; -use syn::{DeriveInput, Path, Type}; - -#[inline] -pub(crate) fn create_debug_map_builder() -> proc_macro2::TokenStream { - quote!( - #[allow(non_camel_case_types)] // We're using __ to help avoid clashes. - struct Educe__RawString(&'static str); - - impl ::core::fmt::Debug for Educe__RawString { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.write_str(self.0) - } - } - - let mut builder = f.debug_map(); - ) -} - -#[inline] -pub(crate) fn create_format_arg( - ast: &DeriveInput, - field_ty: &Type, - format_method: &Path, - field_expr: proc_macro2::TokenStream, -) -> proc_macro2::TokenStream { - let ty_ident = &ast.ident; - - // We use the complete original generics, not filtered by field, - // and include a PhantomData<Self> in our wrapper struct to use the generics. - // - // This avoids having to try to calculate the right *subset* of the generics - // relevant for this field, which is nontrivial and maybe impossible. - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - quote!( - let arg = { - #[allow(non_camel_case_types)] // We're using __ to help avoid clashes. - struct Educe__DebugField<V, M>(V, ::core::marker::PhantomData<M>); - - impl #impl_generics ::core::fmt::Debug - for Educe__DebugField<&#field_ty, #ty_ident #ty_generics> - #where_clause - { - #[inline] - fn fmt(&self, educe__f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - #format_method(self.0, educe__f) - } - } - - Educe__DebugField(#field_expr, ::core::marker::PhantomData::<Self>) - }; - ) -} diff --git a/vendor/educe/src/trait_handlers/debug/debug_enum.rs b/vendor/educe/src/trait_handlers/debug/debug_enum.rs deleted file mode 100644 index 1e423818..00000000 --- a/vendor/educe/src/trait_handlers/debug/debug_enum.rs +++ /dev/null @@ -1,371 +0,0 @@ -use quote::{format_ident, quote, ToTokens}; -use syn::{Data, DeriveInput, Fields, Meta, Type}; - -use super::models::{FieldAttributeBuilder, FieldName, TypeAttributeBuilder, TypeName}; -use crate::{common::path::path_to_string, supported_traits::Trait, trait_handlers::TraitHandler}; - -pub(crate) struct DebugEnumHandler; - -impl TraitHandler for DebugEnumHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_unsafe: false, - enable_name: true, - enable_named_field: false, - enable_bound: true, - name: TypeName::Disable, - named_field: false, - } - .build_from_debug_meta(meta)?; - - let name = type_attribute.name.to_ident_by_ident(&ast.ident); - - let mut debug_types: Vec<&Type> = Vec::new(); - - let mut builder_token_stream = proc_macro2::TokenStream::new(); - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - for variant in data.variants.iter() { - let type_attribute = TypeAttributeBuilder { - enable_flag: false, - enable_unsafe: false, - enable_name: true, - enable_named_field: true, - enable_bound: false, - name: TypeName::Default, - named_field: matches!(&variant.fields, Fields::Named(_)), - } - .build_from_attributes(&variant.attrs, traits)?; - - let variant_ident = &variant.ident; - - let variant_name = type_attribute.name.to_ident_by_ident(variant_ident); - - let named_field = type_attribute.named_field; - - let name_string = if let Some(name) = name { - if let Some(variant_name) = variant_name { - Some(path_to_string(&syn::parse2(quote!(#name::#variant_name)).unwrap())) - } else { - Some(name.into_token_stream().to_string()) - } - } else { - variant_name.map(|variant_name| variant_name.into_token_stream().to_string()) - }; - - match &variant.fields { - Fields::Unit => { - if name_string.is_none() { - return Err(super::panic::unit_variant_need_name(variant)); - } - - arms_token_stream - .extend(quote!( Self::#variant_ident => f.write_str(#name_string), )); - }, - Fields::Named(fields) => { - let mut has_fields = false; - - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - if named_field { - block_token_stream - .extend(create_named_field_builder(name_string.as_deref())); - - for field in fields.named.iter() { - let field_attribute = FieldAttributeBuilder { - enable_name: true, - enable_ignore: true, - enable_method: true, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_var = format_ident!("_{}", field_name_real); - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(#field_name_real: _,)); - - continue; - } - - let key = match field_attribute.name { - FieldName::Custom(name) => name, - FieldName::Default => field_name_real.clone(), - }; - - pattern_token_stream - .extend(quote!(#field_name_real: #field_name_var,)); - - let ty = &field.ty; - - if let Some(method) = field_attribute.method { - block_token_stream.extend(super::common::create_format_arg( - ast, - ty, - &method, - quote!(#field_name_var), - )); - - block_token_stream.extend(if name_string.is_some() { - quote! (builder.field(stringify!(#key), &arg);) - } else { - quote! (builder.entry(&Educe__RawString(stringify!(#key)), &arg);) - }); - } else { - debug_types.push(ty); - - block_token_stream.extend(if name_string.is_some() { - quote! (builder.field(stringify!(#key), #field_name_var);) - } else { - quote! (builder.entry(&Educe__RawString(stringify!(#key)), #field_name_var);) - }); - } - - has_fields = true; - } - } else { - block_token_stream - .extend(quote!(let mut builder = f.debug_tuple(#name_string);)); - - for field in fields.named.iter() { - let field_attribute = FieldAttributeBuilder { - enable_name: false, - enable_ignore: true, - enable_method: true, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_var = format_ident!("_{}", field_name_real); - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(#field_name_real: _,)); - - continue; - } - - pattern_token_stream - .extend(quote!(#field_name_real: #field_name_var,)); - - let ty = &field.ty; - - if let Some(method) = field_attribute.method { - block_token_stream.extend(super::common::create_format_arg( - ast, - ty, - &method, - quote!(#field_name_var), - )); - - block_token_stream.extend(quote! (builder.field(&arg);)); - } else { - debug_types.push(ty); - - block_token_stream - .extend(quote! (builder.field(#field_name_var);)); - } - - has_fields = true; - } - } - - if !has_fields && name_string.is_none() { - return Err(super::panic::unit_struct_need_name(variant_ident)); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident { #pattern_token_stream } => { - #block_token_stream - - builder.finish() - }, - }); - }, - Fields::Unnamed(fields) => { - let mut has_fields = false; - - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - if named_field { - block_token_stream - .extend(create_named_field_builder(name_string.as_deref())); - - for (index, field) in fields.unnamed.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_name: true, - enable_ignore: true, - enable_method: true, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(_,)); - - continue; - } - - let field_name_var = format_ident!("_{}", index); - - let key = match field_attribute.name { - FieldName::Custom(name) => name, - FieldName::Default => field_name_var.clone(), - }; - - pattern_token_stream.extend(quote!(#field_name_var,)); - - let ty = &field.ty; - - if let Some(method) = field_attribute.method { - block_token_stream.extend(super::common::create_format_arg( - ast, - ty, - &method, - quote!(#field_name_var), - )); - - block_token_stream.extend(if name_string.is_some() { - quote! (builder.field(stringify!(#key), &arg);) - } else { - quote! (builder.entry(&Educe__RawString(stringify!(#key)), &arg);) - }); - } else { - debug_types.push(ty); - - block_token_stream.extend(if name_string.is_some() { - quote! (builder.field(stringify!(#key), #field_name_var);) - } else { - quote! (builder.entry(&Educe__RawString(stringify!(#key)), #field_name_var);) - }); - } - - has_fields = true; - } - } else { - block_token_stream - .extend(quote!(let mut builder = f.debug_tuple(#name_string);)); - - for (index, field) in fields.unnamed.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_name: false, - enable_ignore: true, - enable_method: true, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(_,)); - - continue; - } - - let field_name_var = format_ident!("_{}", index); - - pattern_token_stream.extend(quote!(#field_name_var,)); - - let ty = &field.ty; - - if let Some(method) = field_attribute.method { - block_token_stream.extend(super::common::create_format_arg( - ast, - ty, - &method, - quote!(#field_name_var), - )); - - block_token_stream.extend(quote! (builder.field(&arg);)); - } else { - debug_types.push(ty); - - block_token_stream - .extend(quote! (builder.field(#field_name_var);)); - } - - has_fields = true; - } - } - - if !has_fields && name_string.is_none() { - return Err(super::panic::unit_struct_need_name(variant_ident)); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => { - #block_token_stream - - builder.finish() - }, - }); - }, - } - } - } - - let ident = &ast.ident; - - if arms_token_stream.is_empty() { - if let Some(ident) = name { - builder_token_stream.extend(quote! { - f.write_str(stringify!(#ident)) - }); - } else { - return Err(super::panic::unit_enum_need_name(ident)); - } - } else { - builder_token_stream.extend(quote! { - match self { - #arms_token_stream - } - }); - } - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::fmt::Debug)).unwrap(), - &debug_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - #builder_token_stream - } - } - }); - - Ok(()) - } -} - -#[inline] -fn create_named_field_builder(name_string: Option<&str>) -> proc_macro2::TokenStream { - if let Some(name_string) = name_string { - quote!(let mut builder = f.debug_struct(#name_string);) - } else { - super::common::create_debug_map_builder() - } -} diff --git a/vendor/educe/src/trait_handlers/debug/debug_struct.rs b/vendor/educe/src/trait_handlers/debug/debug_struct.rs deleted file mode 100644 index 6430480b..00000000 --- a/vendor/educe/src/trait_handlers/debug/debug_struct.rs +++ /dev/null @@ -1,185 +0,0 @@ -use quote::{format_ident, quote}; -use syn::{Data, DeriveInput, Fields, Meta, Type}; - -use super::{ - models::{FieldAttributeBuilder, FieldName, TypeAttributeBuilder, TypeName}, - TraitHandler, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub struct DebugStructHandler; - -impl TraitHandler for DebugStructHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let is_tuple = { - if let Data::Struct(data) = &ast.data { - matches!(data.fields, Fields::Unnamed(_)) - } else { - true - } - }; - - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_unsafe: false, - enable_name: true, - enable_named_field: true, - enable_bound: true, - name: TypeName::Default, - named_field: !is_tuple, - } - .build_from_debug_meta(meta)?; - - let name = type_attribute.name.to_ident_by_ident(&ast.ident); - - let mut debug_types: Vec<&Type> = Vec::new(); - - let mut builder_token_stream = proc_macro2::TokenStream::new(); - let mut has_fields = false; - - if type_attribute.named_field { - builder_token_stream.extend(if let Some(name) = name { - quote!(let mut builder = f.debug_struct(stringify!(#name));) - } else { - super::common::create_debug_map_builder() - }); - - if let Data::Struct(data) = &ast.data { - for (index, field) in data.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_name: true, - enable_ignore: true, - enable_method: true, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - continue; - } - - let (key, field_name) = match field_attribute.name { - FieldName::Custom(name) => { - (name, IdentOrIndex::from_ident_with_index(field.ident.as_ref(), index)) - }, - FieldName::Default => { - if let Some(ident) = field.ident.as_ref() { - (ident.clone(), IdentOrIndex::from(ident)) - } else { - (format_ident!("_{}", index), IdentOrIndex::from(index)) - } - }, - }; - - let ty = &field.ty; - - if let Some(method) = field_attribute.method { - builder_token_stream.extend(super::common::create_format_arg( - ast, - ty, - &method, - quote!(&self.#field_name), - )); - - builder_token_stream.extend(if name.is_some() { - quote! (builder.field(stringify!(#key), &arg);) - } else { - quote! (builder.entry(&Educe__RawString(stringify!(#key)), &arg);) - }); - } else { - debug_types.push(ty); - - builder_token_stream.extend(if name.is_some() { - quote! (builder.field(stringify!(#key), &self.#field_name);) - } else { - quote! (builder.entry(&Educe__RawString(stringify!(#key)), &self.#field_name);) - }); - } - - has_fields = true; - } - } - } else { - builder_token_stream - .extend(quote!(let mut builder = f.debug_tuple(stringify!(#name));)); - - if let Data::Struct(data) = &ast.data { - for (index, field) in data.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_name: false, - enable_ignore: true, - enable_method: true, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - continue; - } - - let field_name = - IdentOrIndex::from_ident_with_index(field.ident.as_ref(), index); - - let ty = &field.ty; - - if let Some(method) = field_attribute.method { - builder_token_stream.extend(super::common::create_format_arg( - ast, - ty, - &method, - quote!(&self.#field_name), - )); - - builder_token_stream.extend(quote! (builder.field(&arg);)); - } else { - debug_types.push(ty); - - builder_token_stream.extend(quote! (builder.field(&self.#field_name);)); - } - - has_fields = true; - } - } - } - - let ident = &ast.ident; - - if !has_fields && name.is_none() { - return Err(super::panic::unit_struct_need_name(ident)); - } - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::fmt::Debug)).unwrap(), - &debug_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { - #builder_token_stream - - builder.finish() - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/debug/debug_union.rs b/vendor/educe/src/trait_handlers/debug/debug_union.rs deleted file mode 100644 index 096ea776..00000000 --- a/vendor/educe/src/trait_handlers/debug/debug_union.rs +++ /dev/null @@ -1,86 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::{ - models::{FieldAttributeBuilder, FieldName, TypeAttributeBuilder, TypeName}, - TraitHandler, -}; -use crate::supported_traits::Trait; - -pub(crate) struct DebugUnionHandler; - -impl TraitHandler for DebugUnionHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_unsafe: true, - enable_name: true, - enable_named_field: false, - enable_bound: false, - name: TypeName::Default, - named_field: false, - } - .build_from_debug_meta(meta)?; - - if !type_attribute.has_unsafe { - return Err(super::panic::union_without_unsafe(meta)); - } - - let name = type_attribute.name.to_ident_by_ident(&ast.ident); - - let mut builder_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Union(data) = &ast.data { - for field in data.fields.named.iter() { - let _ = FieldAttributeBuilder { - enable_name: false, - enable_ignore: false, - enable_method: false, - name: FieldName::Default, - } - .build_from_attributes(&field.attrs, traits)?; - } - - if let Some(name) = name { - builder_token_stream.extend(quote!( - let mut builder = f.debug_tuple(stringify!(#name)); - - let size = ::core::mem::size_of::<Self>(); - - let data = unsafe { ::core::slice::from_raw_parts(self as *const Self as *const u8, size) }; - - builder.field(&data); - - builder.finish() - )); - } else { - builder_token_stream.extend(quote!( - let size = ::core::mem::size_of::<Self>(); - let data = unsafe { ::core::slice::from_raw_parts(self as *const Self as *const u8, size) }; - - ::core::fmt::Debug::fmt(data, f) - )); - } - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - #builder_token_stream - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/debug/mod.rs b/vendor/educe/src/trait_handlers/debug/mod.rs deleted file mode 100644 index 367ddb71..00000000 --- a/vendor/educe/src/trait_handlers/debug/mod.rs +++ /dev/null @@ -1,38 +0,0 @@ -mod common; -mod debug_enum; -mod debug_struct; -mod debug_union; -mod models; -mod panic; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct DebugHandler; - -impl TraitHandler for DebugHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => debug_struct::DebugStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => { - debug_enum::DebugEnumHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Union(_) => { - debug_union::DebugUnionHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - } - } -} diff --git a/vendor/educe/src/trait_handlers/debug/models/field_attribute.rs b/vendor/educe/src/trait_handlers/debug/models/field_attribute.rs deleted file mode 100644 index f2cd3e28..00000000 --- a/vendor/educe/src/trait_handlers/debug/models/field_attribute.rs +++ /dev/null @@ -1,224 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Ident, Meta, Path, Token}; - -use crate::{ - common::{ - ident_bool::{ - meta_2_bool_allow_path, meta_2_ident, meta_name_value_2_bool, meta_name_value_2_ident, - meta_name_value_2_ident_and_bool, IdentOrBool, - }, - path::meta_2_path, - }, - panic, - supported_traits::Trait, -}; - -#[derive(Debug, Clone)] -pub(crate) enum FieldName { - Default, - Custom(Ident), -} - -pub(crate) struct FieldAttribute { - pub(crate) name: FieldName, - pub(crate) ignore: bool, - pub(crate) method: Option<Path>, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_name: bool, - pub(crate) enable_ignore: bool, - pub(crate) enable_method: bool, - pub(crate) name: FieldName, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_debug_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Debug")); - - let mut name = self.name.clone(); - let mut ignore = false; - let mut method = None; - - let correct_usage_for_debug_attribute = { - let mut usage = vec![]; - - if self.enable_name { - usage.push(stringify!(#[educe(Debug = NewName)])); - usage.push(stringify!(#[educe(Debug(name(NewName)))])); - } - - if self.enable_ignore { - usage.push(stringify!(#[educe(Debug = false)])); - usage.push(stringify!(#[educe(Debug(ignore))])); - } - - if self.enable_method { - usage.push(stringify!(#[educe(Debug(method(path_to_method)))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_debug_attribute, - )); - }, - Meta::NameValue(name_value) => { - if self.enable_name { - if self.enable_ignore { - match meta_name_value_2_ident_and_bool(name_value)? { - IdentOrBool::Ident(ident) => { - name = FieldName::Custom(ident); - }, - IdentOrBool::Bool(b) => { - ignore = !b; - }, - } - } else { - name = FieldName::Custom(meta_name_value_2_ident(name_value)?); - } - } else if self.enable_ignore { - ignore = !meta_name_value_2_bool(name_value)?; - } else { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_debug_attribute, - )); - } - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut name_is_set = false; - let mut ignore_is_set = false; - let mut method_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "name" | "rename" => { - if !self.enable_name { - return Ok(false); - } - - let v = meta_2_ident(&meta)?; - - if name_is_set { - return Err(panic::parameter_reset(ident)); - } - - name_is_set = true; - - name = FieldName::Custom(v); - - return Ok(true); - }, - "ignore" => { - if !self.enable_ignore { - return Ok(false); - } - - let v = meta_2_bool_allow_path(&meta)?; - - if ignore_is_set { - return Err(panic::parameter_reset(ident)); - } - - ignore_is_set = true; - - ignore = v; - - return Ok(true); - }, - "method" => { - if !self.enable_method { - return Ok(false); - } - - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_debug_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - name, - ignore, - method, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Debug { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_debug_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - name: self.name.clone(), - ignore: false, - method: None, - })) - } -} diff --git a/vendor/educe/src/trait_handlers/debug/models/mod.rs b/vendor/educe/src/trait_handlers/debug/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/debug/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/debug/models/type_attribute.rs b/vendor/educe/src/trait_handlers/debug/models/type_attribute.rs deleted file mode 100644 index ed84ddf3..00000000 --- a/vendor/educe/src/trait_handlers/debug/models/type_attribute.rs +++ /dev/null @@ -1,264 +0,0 @@ -use proc_macro2::Ident; -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{ - common::{ - bound::Bound, - ident_bool::{meta_2_bool, meta_2_ident_and_bool, meta_name_value_2_ident, IdentOrBool}, - unsafe_punctuated_meta::UnsafePunctuatedMeta, - }, - panic, Trait, -}; - -#[derive(Debug, Clone)] -pub(crate) enum TypeName { - Disable, - Default, - Custom(Ident), -} - -impl TypeName { - #[inline] - pub(crate) fn to_ident_by_ident<'a, 'b: 'a>(&'a self, ident: &'b Ident) -> Option<&'a Ident> { - match self { - Self::Disable => None, - Self::Default => Some(ident), - Self::Custom(ident) => Some(ident), - } - } -} - -pub(crate) struct TypeAttribute { - pub(crate) has_unsafe: bool, - pub(crate) name: TypeName, - pub(crate) named_field: bool, - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_unsafe: bool, - pub(crate) enable_name: bool, - pub(crate) enable_named_field: bool, - pub(crate) enable_bound: bool, - pub(crate) name: TypeName, - pub(crate) named_field: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_debug_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Debug")); - - let mut has_unsafe = false; - let mut name = self.name.clone(); - let mut named_field = self.named_field; - let mut bound = Bound::Auto; - - let correct_usage_for_debug_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Debug)])); - } - - if self.enable_name { - if !self.enable_unsafe { - usage.push(stringify!(#[educe(Debug = NewName)])); - } - - usage.push(stringify!(#[educe(Debug(name(NewName)))])); - - if let TypeName::Disable = &name { - usage.push(stringify!(#[educe(Debug(name = true))])); - } else { - usage.push(stringify!(#[educe(Debug(name = false))])); - } - } - - if self.enable_named_field { - if !self.named_field { - usage.push(stringify!(#[educe(Debug(named_field = true))])); - } else { - usage.push(stringify!(#[educe(Debug(named_field = false))])); - } - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Debug(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Debug(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_debug_attribute, - )); - } - }, - Meta::NameValue(name_value) => { - if !self.enable_name { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_debug_attribute, - )); - } - - name = TypeName::Custom(meta_name_value_2_ident(name_value)?); - }, - Meta::List(list) => { - let result = if self.enable_unsafe { - let result: UnsafePunctuatedMeta = list.parse_args()?; - - has_unsafe = result.has_unsafe; - - result.list - } else { - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)? - }; - - let mut name_is_set = false; - let mut named_field_is_set = false; - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "name" | "rename" => { - if !self.enable_name { - return Ok(false); - } - - let v = meta_2_ident_and_bool(&meta)?; - - if name_is_set { - return Err(panic::parameter_reset(ident)); - } - - name_is_set = true; - - name = match v { - IdentOrBool::Ident(ident) => TypeName::Custom(ident), - IdentOrBool::Bool(b) => { - if b { - TypeName::Default - } else { - TypeName::Disable - } - }, - }; - - return Ok(true); - }, - "named_field" => { - if !self.enable_named_field { - return Ok(false); - } - - let v = meta_2_bool(&meta)?; - - if named_field_is_set { - return Err(panic::parameter_reset(ident)); - } - - named_field_is_set = true; - - named_field = v; - - return Ok(true); - }, - "bound" => { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_debug_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - has_unsafe, - name, - named_field, - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Debug { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_debug_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - has_unsafe: false, - name: self.name.clone(), - named_field: self.named_field, - bound: Bound::Auto, - })) - } -} diff --git a/vendor/educe/src/trait_handlers/debug/panic.rs b/vendor/educe/src/trait_handlers/debug/panic.rs deleted file mode 100644 index a29646a7..00000000 --- a/vendor/educe/src/trait_handlers/debug/panic.rs +++ /dev/null @@ -1,43 +0,0 @@ -use quote::ToTokens; -use syn::{spanned::Spanned, Ident, Meta, Variant}; - -#[inline] -pub(crate) fn unit_struct_need_name(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), "a unit struct needs to have a name") -} - -#[inline] -pub(crate) fn unit_variant_need_name(variant: &Variant) -> syn::Error { - syn::Error::new( - variant.span(), - "a unit variant which doesn't use an enum name needs to have a name", - ) -} - -#[inline] -pub(crate) fn unit_enum_need_name(name: &Ident) -> syn::Error { - syn::Error::new(name.span(), "a unit enum needs to have a name") -} - -#[inline] -pub(crate) fn union_without_unsafe(meta: &Meta) -> syn::Error { - let mut s = meta.into_token_stream().to_string().replace(" , ", ", "); - - match s.len() { - 5 => s.push_str("(unsafe)"), - 7 => s.insert_str(6, "unsafe"), - _ => s.insert_str(6, "unsafe, "), - } - - syn::Error::new( - meta.span(), - format!( - "a union's `Debug` implementation may expose uninitialized memory\n* It is \ - recommended that, for a union where `Debug` is implemented, types that allow \ - uninitialized memory should not be used in it.\n* If you can ensure that the union \ - uses no such types, use `#[educe({s})]` to implement the `Debug` trait for it.\n* \ - The `unsafe` keyword should be placed as the first parameter of the `Debug` \ - attribute." - ), - ) -} diff --git a/vendor/educe/src/trait_handlers/default/default_enum.rs b/vendor/educe/src/trait_handlers/default/default_enum.rs deleted file mode 100644 index 8aa4ec6e..00000000 --- a/vendor/educe/src/trait_handlers/default/default_enum.rs +++ /dev/null @@ -1,230 +0,0 @@ -use quote::quote; -use syn::{spanned::Spanned, Data, DeriveInput, Fields, Meta, Type, Variant}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::Trait; - -pub(crate) struct DefaultEnumHandler; - -impl TraitHandler for DefaultEnumHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_new: true, - enable_expression: true, - enable_bound: true, - } - .build_from_default_meta(meta)?; - - let mut default_types: Vec<&Type> = Vec::new(); - - let mut default_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - if let Some(expression) = type_attribute.expression { - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, - enable_new: false, - enable_expression: false, - enable_bound: false, - } - .build_from_attributes(&variant.attrs, traits)?; - - ensure_fields_no_attribute(&variant.fields, traits)?; - } - - default_token_stream.extend(quote!(#expression)); - } else { - let variant = { - let variants = &data.variants; - - if variants.len() == 1 { - let variant = &variants[0]; - - let _ = TypeAttributeBuilder { - enable_flag: true, - enable_new: false, - enable_expression: false, - enable_bound: false, - } - .build_from_attributes(&variant.attrs, traits)?; - - variant - } else { - let mut default_variant: Option<&Variant> = None; - - for variant in variants { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_new: false, - enable_expression: false, - enable_bound: false, - } - .build_from_attributes(&variant.attrs, traits)?; - - if type_attribute.flag { - if default_variant.is_some() { - return Err(super::panic::multiple_default_variants( - type_attribute.span, - )); - } - - default_variant = Some(variant); - } else { - ensure_fields_no_attribute(&variant.fields, traits)?; - } - } - - if let Some(default_variant) = default_variant { - default_variant - } else { - return Err(super::panic::no_default_variant(meta.span())); - } - } - }; - - let variant_ident = &variant.ident; - - match &variant.fields { - Fields::Unit => { - default_token_stream.extend(quote!(Self::#variant_ident)); - }, - Fields::Named(_) => { - let mut fields_token_stream = proc_macro2::TokenStream::new(); - - for field in variant.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_flag: false, - enable_expression: true, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - - let field_name = field.ident.as_ref().unwrap(); - - if let Some(expression) = field_attribute.expression { - fields_token_stream.extend(quote! { - #field_name: #expression, - }); - } else { - let ty = &field.ty; - - default_types.push(ty); - - fields_token_stream.extend(quote! { - #field_name: <#ty as ::core::default::Default>::default(), - }); - } - } - - default_token_stream.extend(quote! { - Self::#variant_ident { - #fields_token_stream - } - }); - }, - Fields::Unnamed(_) => { - let mut fields_token_stream = proc_macro2::TokenStream::new(); - - for field in variant.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_flag: false, - enable_expression: true, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - - if let Some(expression) = field_attribute.expression { - fields_token_stream.extend(quote!(#expression,)); - } else { - let ty = &field.ty; - - default_types.push(ty); - - fields_token_stream - .extend(quote!(<#ty as ::core::default::Default>::default(),)); - } - } - - default_token_stream - .extend(quote!(Self::#variant_ident ( #fields_token_stream ))); - }, - } - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::default::Default)).unwrap(), - &default_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::default::Default for #ident #ty_generics #where_clause { - #[inline] - fn default() -> Self { - #default_token_stream - } - } - }); - - if type_attribute.new { - token_stream.extend(quote! { - impl #impl_generics #ident #ty_generics #where_clause { - /// Returns the "default value" for a type. - #[inline] - pub fn new() -> Self { - <Self as ::core::default::Default>::default() - } - } - }); - } - - Ok(()) - } -} - -fn ensure_fields_no_attribute(fields: &Fields, traits: &[Trait]) -> syn::Result<()> { - match fields { - Fields::Unit => (), - Fields::Named(fields) => { - for field in fields.named.iter() { - let _ = FieldAttributeBuilder { - enable_flag: false, - enable_expression: false, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - } - }, - Fields::Unnamed(fields) => { - for field in fields.unnamed.iter() { - let _ = FieldAttributeBuilder { - enable_flag: false, - enable_expression: false, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - } - }, - } - - Ok(()) -} diff --git a/vendor/educe/src/trait_handlers/default/default_struct.rs b/vendor/educe/src/trait_handlers/default/default_struct.rs deleted file mode 100644 index ea25b565..00000000 --- a/vendor/educe/src/trait_handlers/default/default_struct.rs +++ /dev/null @@ -1,149 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Fields, Meta, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::Trait; - -pub(crate) struct DefaultStructHandler; - -impl TraitHandler for DefaultStructHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_new: true, - enable_expression: true, - enable_bound: true, - } - .build_from_default_meta(meta)?; - - let mut default_types: Vec<&Type> = Vec::new(); - - let mut default_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - if let Some(expression) = type_attribute.expression { - for field in data.fields.iter() { - let _ = FieldAttributeBuilder { - enable_flag: false, - enable_expression: false, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - } - - default_token_stream.extend(quote!(#expression)); - } else { - match &data.fields { - Fields::Unit => { - default_token_stream.extend(quote!(Self)); - }, - Fields::Named(_) => { - let mut fields_token_stream = proc_macro2::TokenStream::new(); - - for field in data.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_flag: false, - enable_expression: true, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - - let field_name = field.ident.as_ref().unwrap(); - - if let Some(expression) = field_attribute.expression { - fields_token_stream.extend(quote! { - #field_name: #expression, - }); - } else { - let ty = &field.ty; - - default_types.push(ty); - - fields_token_stream.extend(quote! { - #field_name: <#ty as ::core::default::Default>::default(), - }); - } - } - - default_token_stream.extend(quote! { - Self { - #fields_token_stream - } - }); - }, - Fields::Unnamed(_) => { - let mut fields_token_stream = proc_macro2::TokenStream::new(); - - for field in data.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_flag: false, - enable_expression: true, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - - if let Some(expression) = field_attribute.expression { - fields_token_stream.extend(quote!(#expression,)); - } else { - let ty = &field.ty; - - default_types.push(ty); - - fields_token_stream - .extend(quote!(<#ty as ::core::default::Default>::default(),)); - } - } - - default_token_stream.extend(quote!(Self ( #fields_token_stream ))); - }, - } - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::default::Default)).unwrap(), - &default_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::default::Default for #ident #ty_generics #where_clause { - #[inline] - fn default() -> Self { - #default_token_stream - } - } - }); - - if type_attribute.new { - token_stream.extend(quote! { - impl #impl_generics #ident #ty_generics #where_clause { - /// Returns the "default value" for a type. - #[inline] - pub fn new() -> Self { - <Self as ::core::default::Default>::default() - } - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/default/default_union.rs b/vendor/educe/src/trait_handlers/default/default_union.rs deleted file mode 100644 index a535c011..00000000 --- a/vendor/educe/src/trait_handlers/default/default_union.rs +++ /dev/null @@ -1,153 +0,0 @@ -use quote::quote; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Meta, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::Trait; - -pub(crate) struct DefaultUnionHandler; - -impl TraitHandler for DefaultUnionHandler { - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_new: true, - enable_expression: true, - enable_bound: true, - } - .build_from_default_meta(meta)?; - - let mut default_types: Vec<&Type> = Vec::new(); - - let mut default_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Union(data) = &ast.data { - if let Some(expression) = type_attribute.expression { - for field in data.fields.named.iter() { - let _ = FieldAttributeBuilder { - enable_flag: false, - enable_expression: false, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - } - - default_token_stream.extend(quote!(#expression)); - } else { - let (field, field_attribute) = - { - let fields = &data.fields.named; - - if fields.len() == 1 { - let field = &fields[0]; - - let field_attribute = FieldAttributeBuilder { - enable_flag: true, - enable_expression: true, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - - (field, field_attribute) - } else { - let mut default_field: Option<(&Field, FieldAttribute)> = None; - - for field in fields { - let field_attribute = FieldAttributeBuilder { - enable_flag: true, - enable_expression: true, - } - .build_from_attributes(&field.attrs, traits, &field.ty)?; - - if field_attribute.flag || field_attribute.expression.is_some() { - if default_field.is_some() { - return Err(super::panic::multiple_default_fields( - field_attribute.span, - )); - } - - default_field = Some((field, field_attribute)); - } - } - - if let Some(default_field) = default_field { - default_field - } else { - return Err(super::panic::no_default_field(meta.span())); - } - } - }; - - let mut fields_token_stream = proc_macro2::TokenStream::new(); - - let field_name = field.ident.as_ref().unwrap(); - - if let Some(expression) = field_attribute.expression { - fields_token_stream.extend(quote! { - #field_name: #expression, - }); - } else { - let ty = &field.ty; - - default_types.push(ty); - - fields_token_stream.extend(quote! { - #field_name: <#ty as ::core::default::Default>::default(), - }); - } - - default_token_stream.extend(quote! { - Self { - #fields_token_stream - } - }); - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::default::Default)).unwrap(), - &default_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::default::Default for #ident #ty_generics #where_clause { - #[inline] - fn default() -> Self { - #default_token_stream - } - } - }); - - if type_attribute.new { - token_stream.extend(quote! { - impl #impl_generics #ident #ty_generics #where_clause { - /// Returns the "default value" for a type. - #[inline] - pub fn new() -> Self { - <Self as ::core::default::Default>::default() - } - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/default/mod.rs b/vendor/educe/src/trait_handlers/default/mod.rs deleted file mode 100644 index 5c1eeb8d..00000000 --- a/vendor/educe/src/trait_handlers/default/mod.rs +++ /dev/null @@ -1,43 +0,0 @@ -mod default_enum; -mod default_struct; -mod default_union; -mod models; -mod panic; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct DefaultHandler; - -impl TraitHandler for DefaultHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => default_struct::DefaultStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => default_enum::DefaultEnumHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Union(_) => default_union::DefaultUnionHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - } - } -} diff --git a/vendor/educe/src/trait_handlers/default/models/field_attribute.rs b/vendor/educe/src/trait_handlers/default/models/field_attribute.rs deleted file mode 100644 index 6c82940d..00000000 --- a/vendor/educe/src/trait_handlers/default/models/field_attribute.rs +++ /dev/null @@ -1,166 +0,0 @@ -use proc_macro2::Span; -use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Expr, Meta, Token, Type}; - -use crate::{ - common::expr::{auto_adjust_expr, meta_2_expr}, - panic, - supported_traits::Trait, -}; - -pub(crate) struct FieldAttribute { - pub(crate) flag: bool, - pub(crate) expression: Option<Expr>, - pub(crate) span: Span, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_expression: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_default_meta( - &self, - meta: &Meta, - ty: &Type, - ) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Default")); - - let mut flag = false; - let mut expression = None; - - let correct_usage_for_default_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Default)])); - } - - if self.enable_expression { - usage.push(stringify!(#[educe(Default = expr)])); - - usage.push(stringify!(#[educe(Default(expression = expr))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_default_attribute, - )); - } - - flag = true; - }, - Meta::NameValue(name_value) => { - if !self.enable_expression { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_default_attribute, - )); - } - - expression = Some(auto_adjust_expr(name_value.value.clone(), Some(ty))); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut expression_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "expression" | "expr" => { - if !self.enable_expression { - return Ok(false); - } - - let v = meta_2_expr(&meta)?; - - if expression_is_set { - return Err(panic::parameter_reset(ident)); - } - - expression_is_set = true; - - expression = Some(auto_adjust_expr(v, Some(ty))); - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_default_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - flag, - expression, - span: meta.span(), - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ty: &Type, - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Default { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_default_meta(&meta, ty)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - flag: false, - expression: None, - span: Span::call_site(), - })) - } -} diff --git a/vendor/educe/src/trait_handlers/default/models/mod.rs b/vendor/educe/src/trait_handlers/default/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/default/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/default/models/type_attribute.rs b/vendor/educe/src/trait_handlers/default/models/type_attribute.rs deleted file mode 100644 index ee0b901b..00000000 --- a/vendor/educe/src/trait_handlers/default/models/type_attribute.rs +++ /dev/null @@ -1,214 +0,0 @@ -use proc_macro2::Span; -use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Expr, Meta, Token}; - -use crate::{ - common::{ - bound::Bound, - expr::{auto_adjust_expr, meta_2_expr}, - ident_bool::meta_2_bool_allow_path, - }, - panic, Trait, -}; - -pub(crate) struct TypeAttribute { - pub(crate) flag: bool, - pub(crate) new: bool, - pub(crate) expression: Option<Expr>, - pub(crate) bound: Bound, - pub(crate) span: Span, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_new: bool, - pub(crate) enable_expression: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_default_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Default")); - - let mut flag = false; - let mut new = false; - let mut expression = None; - let mut bound = Bound::Auto; - - let correct_usage_for_default_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Default)])); - } - - if self.enable_new { - usage.push(stringify!(#[educe(Default(new))])); - } - - if self.enable_expression { - usage.push(stringify!(#[educe(Default(expression = expr))])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Default(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Default(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_default_attribute, - )); - } - - flag = true; - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_default_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut new_is_set = false; - let mut expression_is_set = false; - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "new" => { - if !self.enable_new { - return Ok(false); - } - - let v = meta_2_bool_allow_path(&meta)?; - - if new_is_set { - return Err(panic::parameter_reset(ident)); - } - - new_is_set = true; - - new = v; - - return Ok(true); - }, - "expression" | "expr" => { - if !self.enable_expression { - return Ok(false); - } - - let v = meta_2_expr(&meta)?; - - if expression_is_set { - return Err(panic::parameter_reset(ident)); - } - - expression_is_set = true; - - expression = Some(auto_adjust_expr(v, None)); - - return Ok(true); - }, - "bound" => { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_default_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - flag, - new, - expression, - bound, - span: meta.span(), - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Default { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_default_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - flag: false, - new: false, - expression: None, - bound: Bound::Auto, - span: Span::call_site(), - })) - } -} diff --git a/vendor/educe/src/trait_handlers/default/panic.rs b/vendor/educe/src/trait_handlers/default/panic.rs deleted file mode 100644 index 9f3598ea..00000000 --- a/vendor/educe/src/trait_handlers/default/panic.rs +++ /dev/null @@ -1,21 +0,0 @@ -use proc_macro2::Span; - -#[inline] -pub(crate) fn multiple_default_fields(span: Span) -> syn::Error { - syn::Error::new(span, "multiple default fields are set") -} - -#[inline] -pub(crate) fn no_default_field(span: Span) -> syn::Error { - syn::Error::new(span, "there is no field set as default") -} - -#[inline] -pub(crate) fn multiple_default_variants(span: Span) -> syn::Error { - syn::Error::new(span, "multiple default variants are set") -} - -#[inline] -pub(crate) fn no_default_variant(span: Span) -> syn::Error { - syn::Error::new(span, "there is no variant set as default") -} diff --git a/vendor/educe/src/trait_handlers/deref/deref_enum.rs b/vendor/educe/src/trait_handlers/deref/deref_enum.rs deleted file mode 100644 index 1c478cc9..00000000 --- a/vendor/educe/src/trait_handlers/deref/deref_enum.rs +++ /dev/null @@ -1,144 +0,0 @@ -use quote::{format_ident, quote}; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Fields, Ident, Meta, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::r#type::dereference, panic, supported_traits::Trait}; - -pub(crate) struct DerefEnumHandler; - -impl TraitHandler for DerefEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let _ = TypeAttributeBuilder { - enable_flag: true - } - .build_from_deref_meta(meta)?; - - let mut target_token_stream = proc_macro2::TokenStream::new(); - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - type Variants<'a> = Vec<(&'a Ident, bool, usize, Ident, &'a Type)>; - - let mut variants: Variants = Vec::new(); - - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false - } - .build_from_attributes(&variant.attrs, traits)?; - - if let Fields::Unit = &variant.fields { - return Err(panic::trait_not_support_unit_variant( - meta.path().get_ident().unwrap(), - variant, - )); - } - - let fields = &variant.fields; - - let (index, field) = if fields.len() == 1 { - let field = fields.into_iter().next().unwrap(); - - let _ = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - (0usize, field) - } else { - let mut deref_field: Option<(usize, &Field)> = None; - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.flag { - if deref_field.is_some() { - return Err(super::panic::multiple_deref_fields_of_variant( - field_attribute.span, - variant, - )); - } - - deref_field = Some((index, field)); - } - } - - if let Some(deref_field) = deref_field { - deref_field - } else { - return Err(super::panic::no_deref_field_of_variant(meta.span(), variant)); - } - }; - - let (field_name, is_tuple): (Ident, bool) = match field.ident.as_ref() { - Some(ident) => (ident.clone(), false), - None => (format_ident!("_{}", index), true), - }; - - variants.push((&variant.ident, is_tuple, index, field_name, &field.ty)); - } - - if variants.is_empty() { - return Err(super::panic::no_deref_field(meta.span())); - } - - let ty = variants[0].4; - let dereference_ty = dereference(ty); - - target_token_stream.extend(quote!(#dereference_ty)); - - for (variant_ident, is_tuple, index, field_name, _) in variants { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - - if is_tuple { - for _ in 0..index { - pattern_token_stream.extend(quote!(_,)); - } - - pattern_token_stream.extend(quote!( #field_name, .. )); - - arms_token_stream.extend( - quote!( Self::#variant_ident ( #pattern_token_stream ) => #field_name, ), - ); - } else { - pattern_token_stream.extend(quote!( #field_name, .. )); - - arms_token_stream.extend( - quote!( Self::#variant_ident { #pattern_token_stream } => #field_name, ), - ); - } - } - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::ops::Deref for #ident #ty_generics #where_clause { - type Target = #target_token_stream; - - #[inline] - fn deref(&self) -> &Self::Target { - match self { - #arms_token_stream - } - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/deref/deref_struct.rs b/vendor/educe/src/trait_handlers/deref/deref_struct.rs deleted file mode 100644 index 8c971308..00000000 --- a/vendor/educe/src/trait_handlers/deref/deref_struct.rs +++ /dev/null @@ -1,103 +0,0 @@ -use quote::quote; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Meta}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{ - common::{ident_index::IdentOrIndex, r#type::dereference_changed}, - Trait, -}; - -pub(crate) struct DerefStructHandler; - -impl TraitHandler for DerefStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let _ = TypeAttributeBuilder { - enable_flag: true - } - .build_from_deref_meta(meta)?; - - let mut target_token_stream = proc_macro2::TokenStream::new(); - let mut deref_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - let (index, field) = { - let fields = &data.fields; - - if fields.len() == 1 { - let field = fields.into_iter().next().unwrap(); - - let _ = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - (0usize, field) - } else { - let mut deref_field: Option<(usize, &Field)> = None; - - for (index, field) in fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.flag { - if deref_field.is_some() { - return Err(super::panic::multiple_deref_fields( - field_attribute.span, - )); - } - - deref_field = Some((index, field)); - } - } - - if let Some(deref_field) = deref_field { - deref_field - } else { - return Err(super::panic::no_deref_field(meta.span())); - } - } - }; - - let ty = &field.ty; - let (dereference_ty, is_ref) = dereference_changed(ty); - - target_token_stream.extend(quote!(#dereference_ty)); - - let field_name = IdentOrIndex::from_ident_with_index(field.ident.as_ref(), index); - - deref_token_stream.extend(if is_ref { - quote! (self.#field_name) - } else { - quote! (&self.#field_name) - }); - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::ops::Deref for #ident #ty_generics #where_clause { - type Target = #target_token_stream; - - #[inline] - fn deref(&self) -> &Self::Target { - #deref_token_stream - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/deref/mod.rs b/vendor/educe/src/trait_handlers/deref/mod.rs deleted file mode 100644 index 1a3263cd..00000000 --- a/vendor/educe/src/trait_handlers/deref/mod.rs +++ /dev/null @@ -1,36 +0,0 @@ -mod deref_enum; -mod deref_struct; -mod models; -mod panic; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct DerefHandler; - -impl TraitHandler for DerefHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => deref_struct::DerefStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => { - deref_enum::DerefEnumHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Union(_) => { - Err(crate::panic::trait_not_support_union(meta.path().get_ident().unwrap())) - }, - } - } -} diff --git a/vendor/educe/src/trait_handlers/deref/models/field_attribute.rs b/vendor/educe/src/trait_handlers/deref/models/field_attribute.rs deleted file mode 100644 index 5f3d3fba..00000000 --- a/vendor/educe/src/trait_handlers/deref/models/field_attribute.rs +++ /dev/null @@ -1,94 +0,0 @@ -use proc_macro2::Span; -use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Meta, Token}; - -use crate::{panic, supported_traits::Trait}; - -pub(crate) struct FieldAttribute { - pub(crate) flag: bool, - pub(crate) span: Span, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_flag: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_deref_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Deref")); - - let correct_usage_for_deref_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Deref)])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_attribute, - )); - } - }, - Meta::NameValue(_) | Meta::List(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_attribute, - )); - }, - } - - Ok(FieldAttribute { - flag: true, span: meta.span() - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Deref { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_deref_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - flag: false, span: Span::call_site() - })) - } -} diff --git a/vendor/educe/src/trait_handlers/deref/models/mod.rs b/vendor/educe/src/trait_handlers/deref/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/deref/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/deref/models/type_attribute.rs b/vendor/educe/src/trait_handlers/deref/models/type_attribute.rs deleted file mode 100644 index 01b9e5e9..00000000 --- a/vendor/educe/src/trait_handlers/deref/models/type_attribute.rs +++ /dev/null @@ -1,87 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{panic, Trait}; - -pub(crate) struct TypeAttribute; - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_deref_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Deref")); - - let correct_usage_for_deref_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Deref)])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_attribute, - )); - } - }, - Meta::NameValue(_) | Meta::List(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_attribute, - )); - }, - } - - Ok(TypeAttribute) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Deref { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_deref_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute)) - } -} diff --git a/vendor/educe/src/trait_handlers/deref/panic.rs b/vendor/educe/src/trait_handlers/deref/panic.rs deleted file mode 100644 index 508b6235..00000000 --- a/vendor/educe/src/trait_handlers/deref/panic.rs +++ /dev/null @@ -1,31 +0,0 @@ -use proc_macro2::Span; -use syn::Variant; - -#[inline] -pub(crate) fn multiple_deref_fields(span: Span) -> syn::Error { - syn::Error::new(span, "multiple fields are set for `Deref`") -} - -#[inline] -pub(crate) fn multiple_deref_fields_of_variant(span: Span, variant: &Variant) -> syn::Error { - syn::Error::new( - span, - format!("multiple fields of the `{}` variant are set for `Deref`", variant.ident), - ) -} - -#[inline] -pub(crate) fn no_deref_field(span: Span) -> syn::Error { - syn::Error::new(span, "there is no field which is assigned for `Deref`") -} - -#[inline] -pub(crate) fn no_deref_field_of_variant(span: Span, variant: &Variant) -> syn::Error { - syn::Error::new( - span, - format!( - "there is no field for the `{}` variant which is assigned for `Deref`", - variant.ident - ), - ) -} diff --git a/vendor/educe/src/trait_handlers/deref_mut/deref_mut_enum.rs b/vendor/educe/src/trait_handlers/deref_mut/deref_mut_enum.rs deleted file mode 100644 index 6ba2f2ed..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/deref_mut_enum.rs +++ /dev/null @@ -1,139 +0,0 @@ -use quote::{format_ident, quote}; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Fields, Ident, Meta}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{panic, supported_traits::Trait}; - -pub(crate) struct DerefMutEnumHandler; - -impl TraitHandler for DerefMutEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let _ = TypeAttributeBuilder { - enable_flag: true - } - .build_from_deref_mut_meta(meta)?; - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - type Variants<'a> = Vec<(&'a Ident, bool, usize, Ident)>; - - let mut variants: Variants = Vec::new(); - - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false - } - .build_from_attributes(&variant.attrs, traits)?; - - if let Fields::Unit = &variant.fields { - return Err(panic::trait_not_support_unit_variant( - meta.path().get_ident().unwrap(), - variant, - )); - } - - let fields = &variant.fields; - - let (index, field) = if fields.len() == 1 { - let field = fields.into_iter().next().unwrap(); - - let _ = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - (0usize, field) - } else { - let mut deref_field: Option<(usize, &Field)> = None; - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.flag { - if deref_field.is_some() { - return Err(super::panic::multiple_deref_mut_fields_of_variant( - field_attribute.span, - variant, - )); - } - - deref_field = Some((index, field)); - } - } - - if let Some(deref_field) = deref_field { - deref_field - } else { - return Err(super::panic::no_deref_mut_field_of_variant( - meta.span(), - variant, - )); - } - }; - - let (field_name, is_tuple): (Ident, bool) = match field.ident.as_ref() { - Some(ident) => (ident.clone(), false), - None => (format_ident!("_{}", index), true), - }; - - variants.push((&variant.ident, is_tuple, index, field_name)); - } - - if variants.is_empty() { - return Err(super::panic::no_deref_mut_field(meta.span())); - } - - for (variant_ident, is_tuple, index, field_name) in variants { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - - if is_tuple { - for _ in 0..index { - pattern_token_stream.extend(quote!(_,)); - } - - pattern_token_stream.extend(quote!( #field_name, .. )); - - arms_token_stream.extend( - quote!( Self::#variant_ident ( #pattern_token_stream ) => #field_name, ), - ); - } else { - pattern_token_stream.extend(quote!( #field_name, .. )); - - arms_token_stream.extend( - quote!( Self::#variant_ident { #pattern_token_stream } => #field_name, ), - ); - } - } - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::ops::DerefMut for #ident #ty_generics #where_clause { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - match self { - #arms_token_stream - } - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/deref_mut/deref_mut_struct.rs b/vendor/educe/src/trait_handlers/deref_mut/deref_mut_struct.rs deleted file mode 100644 index deb58880..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/deref_mut_struct.rs +++ /dev/null @@ -1,92 +0,0 @@ -use quote::quote; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Meta, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub(crate) struct DerefMutStructHandler; - -impl TraitHandler for DerefMutStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let _ = TypeAttributeBuilder { - enable_flag: true - } - .build_from_deref_mut_meta(meta)?; - - let mut deref_mut_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - let (index, field) = { - let fields = &data.fields; - - if fields.len() == 1 { - let field = fields.into_iter().next().unwrap(); - - let _ = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - (0usize, field) - } else { - let mut deref_field: Option<(usize, &Field)> = None; - - for (index, field) in fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_flag: true - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.flag { - if deref_field.is_some() { - return Err(super::panic::multiple_deref_mut_fields( - field_attribute.span, - )); - } - - deref_field = Some((index, field)); - } - } - - if let Some(deref_field) = deref_field { - deref_field - } else { - return Err(super::panic::no_deref_mut_field(meta.span())); - } - } - }; - - let field_name = IdentOrIndex::from_ident_with_index(field.ident.as_ref(), index); - - deref_mut_token_stream.extend(if let Type::Reference(_) = &field.ty { - quote! (self.#field_name) - } else { - quote! (&mut self.#field_name) - }); - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::ops::DerefMut for #ident #ty_generics #where_clause { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - #deref_mut_token_stream - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/deref_mut/mod.rs b/vendor/educe/src/trait_handlers/deref_mut/mod.rs deleted file mode 100644 index 01f09912..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/mod.rs +++ /dev/null @@ -1,39 +0,0 @@ -mod deref_mut_enum; -mod deref_mut_struct; -mod models; -mod panic; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct DerefMutHandler; - -impl TraitHandler for DerefMutHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => deref_mut_struct::DerefMutStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => deref_mut_enum::DerefMutEnumHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Union(_) => { - Err(crate::panic::trait_not_support_union(meta.path().get_ident().unwrap())) - }, - } - } -} diff --git a/vendor/educe/src/trait_handlers/deref_mut/models/field_attribute.rs b/vendor/educe/src/trait_handlers/deref_mut/models/field_attribute.rs deleted file mode 100644 index e04543e4..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/models/field_attribute.rs +++ /dev/null @@ -1,94 +0,0 @@ -use proc_macro2::Span; -use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Meta, Token}; - -use crate::{panic, supported_traits::Trait}; - -pub(crate) struct FieldAttribute { - pub(crate) flag: bool, - pub(crate) span: Span, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_flag: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_deref_mut_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("DerefMut")); - - let correct_usage_for_deref_mut_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(DerefMut)])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_mut_attribute, - )); - } - }, - Meta::NameValue(_) | Meta::List(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_mut_attribute, - )); - }, - } - - Ok(FieldAttribute { - flag: true, span: meta.span() - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::DerefMut { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_deref_mut_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - flag: false, span: Span::call_site() - })) - } -} diff --git a/vendor/educe/src/trait_handlers/deref_mut/models/mod.rs b/vendor/educe/src/trait_handlers/deref_mut/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/deref_mut/models/type_attribute.rs b/vendor/educe/src/trait_handlers/deref_mut/models/type_attribute.rs deleted file mode 100644 index 782d1361..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/models/type_attribute.rs +++ /dev/null @@ -1,87 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{panic, Trait}; - -pub(crate) struct TypeAttribute; - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_deref_mut_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("DerefMut")); - - let correct_usage_for_deref_mut_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(DerefMut)])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_mut_attribute, - )); - } - }, - Meta::NameValue(_) | Meta::List(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_deref_mut_attribute, - )); - }, - } - - Ok(TypeAttribute) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::DerefMut { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_deref_mut_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute)) - } -} diff --git a/vendor/educe/src/trait_handlers/deref_mut/panic.rs b/vendor/educe/src/trait_handlers/deref_mut/panic.rs deleted file mode 100644 index d7b14660..00000000 --- a/vendor/educe/src/trait_handlers/deref_mut/panic.rs +++ /dev/null @@ -1,31 +0,0 @@ -use proc_macro2::Span; -use syn::Variant; - -#[inline] -pub(crate) fn multiple_deref_mut_fields(span: Span) -> syn::Error { - syn::Error::new(span, "multiple fields are set for `DerefMut`") -} - -#[inline] -pub(crate) fn multiple_deref_mut_fields_of_variant(span: Span, variant: &Variant) -> syn::Error { - syn::Error::new( - span, - format!("multiple fields of the `{}` variant are set for `DerefMut`", variant.ident), - ) -} - -#[inline] -pub(crate) fn no_deref_mut_field(span: Span) -> syn::Error { - syn::Error::new(span, "there is no field which is assigned for `DerefMut`") -} - -#[inline] -pub(crate) fn no_deref_mut_field_of_variant(span: Span, variant: &Variant) -> syn::Error { - syn::Error::new( - span, - format!( - "there is no field for the `{}` variant which is assigned for `DerefMut`", - variant.ident - ), - ) -} diff --git a/vendor/educe/src/trait_handlers/eq/mod.rs b/vendor/educe/src/trait_handlers/eq/mod.rs deleted file mode 100644 index bff020d7..00000000 --- a/vendor/educe/src/trait_handlers/eq/mod.rs +++ /dev/null @@ -1,106 +0,0 @@ -mod models; - -use models::{FieldAttributeBuilder, TypeAttributeBuilder}; -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct EqHandler; - -impl TraitHandler for EqHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - #[cfg(feature = "PartialEq")] - let contains_partial_eq = traits.contains(&Trait::PartialEq); - - #[cfg(not(feature = "PartialEq"))] - let contains_partial_eq = false; - - let type_attribute = TypeAttributeBuilder { - enable_flag: true, - enable_bound: !contains_partial_eq, - } - .build_from_eq_meta(meta)?; - - let mut field_types = vec![]; - - // if `contains_partial_eq` is true, the implementation is handled by the `PartialEq` attribute, and field attributes is also handled by the `PartialEq` attribute - if !contains_partial_eq { - match &ast.data { - Data::Struct(data) => { - for field in data.fields.iter() { - field_types.push(&field.ty); - let _ = - FieldAttributeBuilder.build_from_attributes(&field.attrs, traits)?; - } - }, - Data::Enum(data) => { - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, enable_bound: false - } - .build_from_attributes(&variant.attrs, traits)?; - - for field in variant.fields.iter() { - field_types.push(&field.ty); - let _ = FieldAttributeBuilder - .build_from_attributes(&field.attrs, traits)?; - } - } - }, - Data::Union(data) => { - for field in data.fields.named.iter() { - field_types.push(&field.ty); - let _ = - FieldAttributeBuilder.build_from_attributes(&field.attrs, traits)?; - } - }, - } - - let ident = &ast.ident; - - /* - #[derive(PartialEq)] - struct B<T> { - f1: PhantomData<T>, - } - - impl<T> Eq for B<T> { - - } - - // The above code will throw a compile error because T have to be bound to `PartialEq`. However, it seems not to be necessary logically. - */ - let bound = - type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::PartialEq)).unwrap(), - &field_types, - &[quote! {::core::cmp::PartialEq}], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::Eq for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/eq/models/field_attribute.rs b/vendor/educe/src/trait_handlers/eq/models/field_attribute.rs deleted file mode 100644 index ce78d6b8..00000000 --- a/vendor/educe/src/trait_handlers/eq/models/field_attribute.rs +++ /dev/null @@ -1,57 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{panic, supported_traits::Trait}; - -pub(crate) struct FieldAttribute; - -pub(crate) struct FieldAttributeBuilder; - -impl FieldAttributeBuilder { - pub(crate) fn build_from_eq_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Eq")); - - return Err(panic::attribute_incorrect_place(meta.path().get_ident().unwrap())); - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Eq { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_eq_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute)) - } -} diff --git a/vendor/educe/src/trait_handlers/eq/models/mod.rs b/vendor/educe/src/trait_handlers/eq/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/eq/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/eq/models/type_attribute.rs b/vendor/educe/src/trait_handlers/eq/models/type_attribute.rs deleted file mode 100644 index 5c537080..00000000 --- a/vendor/educe/src/trait_handlers/eq/models/type_attribute.rs +++ /dev/null @@ -1,140 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{common::bound::Bound, panic, Trait}; - -pub(crate) struct TypeAttribute { - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_eq_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Eq")); - - let mut bound = Bound::Auto; - - let correct_usage_for_copy_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Eq)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Eq(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Eq(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_copy_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_copy_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_copy_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Eq { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_eq_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/hash/hash_enum.rs b/vendor/educe/src/trait_handlers/hash/hash_enum.rs deleted file mode 100644 index 01337029..00000000 --- a/vendor/educe/src/trait_handlers/hash/hash_enum.rs +++ /dev/null @@ -1,169 +0,0 @@ -use quote::{format_ident, quote}; -use syn::{Data, DeriveInput, Fields, Meta, Path, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::Trait; - -pub(crate) struct HashEnumHandler; - -impl TraitHandler for HashEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = - TypeAttributeBuilder { - enable_flag: true, enable_unsafe: false, enable_bound: true - } - .build_from_hash_meta(meta)?; - - let mut hash_types: Vec<&Type> = Vec::new(); - - let mut hash_token_stream = proc_macro2::TokenStream::new(); - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - for (variant_index, variant) in data.variants.iter().enumerate() { - let _ = TypeAttributeBuilder { - enable_flag: false, - enable_unsafe: false, - enable_bound: false, - } - .build_from_attributes(&variant.attrs, traits)?; - - let variant_ident = &variant.ident; - - let built_in_hash: Path = syn::parse2(quote!(::core::hash::Hash::hash)).unwrap(); - - match &variant.fields { - Fields::Unit => { - arms_token_stream.extend(quote! { - Self::#variant_ident => { - ::core::hash::Hash::hash(&#variant_index, state); - } - }); - }, - Fields::Named(_) => { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - for field in variant.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_var = format_ident!("v_{}", field_name_real); - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(#field_name_real: _,)); - - continue; - } - - pattern_token_stream.extend(quote!(#field_name_real: #field_name_var,)); - - let hash = field_attribute.method.as_ref().unwrap_or_else(|| { - hash_types.push(&field.ty); - &built_in_hash - }); - - block_token_stream.extend(quote!( #hash(#field_name_var, state); )); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident { #pattern_token_stream } => { - ::core::hash::Hash::hash(&#variant_index, state); - - #block_token_stream - } - }); - }, - Fields::Unnamed(_) => { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_var = format_ident!("_{}", index); - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(_,)); - - continue; - } - - pattern_token_stream.extend(quote!(#field_name_var,)); - - let hash = field_attribute.method.as_ref().unwrap_or_else(|| { - hash_types.push(&field.ty); - &built_in_hash - }); - - block_token_stream.extend(quote!( #hash(#field_name_var, state); )); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => { - ::core::hash::Hash::hash(&#variant_index, state); - - #block_token_stream - } - }); - }, - } - } - } - - if !arms_token_stream.is_empty() { - hash_token_stream.extend(quote! { - match self { - #arms_token_stream - } - }); - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::hash::Hash)).unwrap(), - &hash_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::hash::Hash for #ident #ty_generics #where_clause { - #[inline] - fn hash<H: ::core::hash::Hasher>(&self, state: &mut H) { - #hash_token_stream - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/hash/hash_struct.rs b/vendor/educe/src/trait_handlers/hash/hash_struct.rs deleted file mode 100644 index 0444e4b0..00000000 --- a/vendor/educe/src/trait_handlers/hash/hash_struct.rs +++ /dev/null @@ -1,88 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Meta, Path, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub(crate) struct HashStructHandler; - -impl TraitHandler for HashStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = - TypeAttributeBuilder { - enable_flag: true, enable_unsafe: false, enable_bound: true - } - .build_from_hash_meta(meta)?; - - let mut hash_types: Vec<&Type> = Vec::new(); - - let mut hash_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - let built_in_hash: Path = syn::parse2(quote!(::core::hash::Hash::hash)).unwrap(); - - for (index, field) in data.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - continue; - } - - let field_name = if let Some(ident) = field.ident.as_ref() { - IdentOrIndex::from(ident) - } else { - IdentOrIndex::from(index) - }; - - let hash = field_attribute.method.as_ref().unwrap_or_else(|| { - hash_types.push(&field.ty); - &built_in_hash - }); - - hash_token_stream.extend(quote!( #hash(&self.#field_name, state); )); - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::hash::Hash)).unwrap(), - &hash_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::hash::Hash for #ident #ty_generics #where_clause { - #[inline] - fn hash<H: ::core::hash::Hasher>(&self, state: &mut H) { - #hash_token_stream - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/hash/hash_union.rs b/vendor/educe/src/trait_handlers/hash/hash_union.rs deleted file mode 100644 index f430c658..00000000 --- a/vendor/educe/src/trait_handlers/hash/hash_union.rs +++ /dev/null @@ -1,54 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::models::{FieldAttributeBuilder, TypeAttributeBuilder}; -use crate::{supported_traits::Trait, trait_handlers::TraitHandler}; - -pub(crate) struct HashUnionHandler; - -impl TraitHandler for HashUnionHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = - TypeAttributeBuilder { - enable_flag: true, enable_unsafe: true, enable_bound: false - } - .build_from_hash_meta(meta)?; - - if !type_attribute.has_unsafe { - return Err(super::panic::union_without_unsafe(meta)); - } - - if let Data::Union(data) = &ast.data { - for field in data.fields.named.iter() { - let _ = FieldAttributeBuilder { - enable_ignore: false, enable_method: false - } - .build_from_attributes(&field.attrs, traits)?; - } - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::hash::Hash for #ident #ty_generics #where_clause { - #[inline] - fn hash<H: ::core::hash::Hasher>(&self, state: &mut H) { - let size = ::core::mem::size_of::<Self>(); - let data = unsafe { ::core::slice::from_raw_parts(self as *const Self as *const u8, size) }; - - ::core::hash::Hash::hash(data, state) - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/hash/mod.rs b/vendor/educe/src/trait_handlers/hash/mod.rs deleted file mode 100644 index c4b07d98..00000000 --- a/vendor/educe/src/trait_handlers/hash/mod.rs +++ /dev/null @@ -1,34 +0,0 @@ -mod hash_enum; -mod hash_struct; -mod hash_union; -mod models; -mod panic; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct HashHandler; - -impl TraitHandler for HashHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => { - hash_struct::HashStructHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Enum(_) => { - hash_enum::HashEnumHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Union(_) => { - hash_union::HashUnionHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - } - } -} diff --git a/vendor/educe/src/trait_handlers/hash/models/field_attribute.rs b/vendor/educe/src/trait_handlers/hash/models/field_attribute.rs deleted file mode 100644 index d6e34b66..00000000 --- a/vendor/educe/src/trait_handlers/hash/models/field_attribute.rs +++ /dev/null @@ -1,172 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Path, Token}; - -use crate::{ - common::{ - ident_bool::{meta_2_bool_allow_path, meta_name_value_2_bool}, - path::meta_2_path, - }, - panic, - supported_traits::Trait, -}; - -pub(crate) struct FieldAttribute { - pub(crate) ignore: bool, - pub(crate) method: Option<Path>, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_ignore: bool, - pub(crate) enable_method: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_hash_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Hash")); - - let mut ignore = false; - let mut method = None; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_ignore { - usage.push(stringify!(#[educe(Hash = false)])); - usage.push(stringify!(#[educe(Hash(ignore))])); - } - - if self.enable_method { - usage.push(stringify!(#[educe(Hash(method(path_to_method)))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::NameValue(name_value) => { - if self.enable_ignore { - ignore = !meta_name_value_2_bool(name_value)?; - } else { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut ignore_is_set = false; - let mut method_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "ignore" => { - if !self.enable_ignore { - return Ok(false); - } - - let v = meta_2_bool_allow_path(&meta)?; - - if ignore_is_set { - return Err(panic::parameter_reset(ident)); - } - - ignore_is_set = true; - - ignore = v; - - return Ok(true); - }, - "method" => { - if !self.enable_method { - return Ok(false); - } - - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - ignore, - method, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Hash { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_hash_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - ignore: false, method: None - })) - } -} diff --git a/vendor/educe/src/trait_handlers/hash/models/mod.rs b/vendor/educe/src/trait_handlers/hash/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/hash/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/hash/models/type_attribute.rs b/vendor/educe/src/trait_handlers/hash/models/type_attribute.rs deleted file mode 100644 index 33b99994..00000000 --- a/vendor/educe/src/trait_handlers/hash/models/type_attribute.rs +++ /dev/null @@ -1,154 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{ - common::{bound::Bound, unsafe_punctuated_meta::UnsafePunctuatedMeta}, - panic, Trait, -}; - -pub(crate) struct TypeAttribute { - pub(crate) has_unsafe: bool, - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_unsafe: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_hash_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Hash")); - - let mut has_unsafe = false; - let mut bound = Bound::Auto; - - let correct_usage_for_hash_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Hash)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Hash(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Hash(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_hash_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_hash_attribute, - )); - }, - Meta::List(list) => { - let result = if self.enable_unsafe { - let result: UnsafePunctuatedMeta = list.parse_args()?; - - has_unsafe = result.has_unsafe; - - result.list - } else { - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)? - }; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_hash_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - has_unsafe, - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Hash { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_hash_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - has_unsafe: false, bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/hash/panic.rs b/vendor/educe/src/trait_handlers/hash/panic.rs deleted file mode 100644 index 6e293571..00000000 --- a/vendor/educe/src/trait_handlers/hash/panic.rs +++ /dev/null @@ -1,22 +0,0 @@ -use quote::ToTokens; -use syn::{spanned::Spanned, Meta}; - -#[inline] -pub(crate) fn union_without_unsafe(meta: &Meta) -> syn::Error { - let mut s = meta.into_token_stream().to_string(); - - match s.len() { - 4 => s.push_str("(unsafe)"), - 6 => s.insert_str(10, "unsafe"), - _ => unreachable!(), - } - - syn::Error::new( - meta.span(), - format!( - "a union's `Hash` implementation is not precise, because it ignores the type of \ - fields\n* If your union doesn't care about that, use `#[educe({s})]` to implement \ - the `Hash` trait for it." - ), - ) -} diff --git a/vendor/educe/src/trait_handlers/into/common.rs b/vendor/educe/src/trait_handlers/into/common.rs deleted file mode 100644 index 2eba04a1..00000000 --- a/vendor/educe/src/trait_handlers/into/common.rs +++ /dev/null @@ -1,17 +0,0 @@ -use quote::quote_spanned; -use syn::{spanned::Spanned, Type}; - -use crate::common::{r#type::dereference_changed, tools::HashType}; - -#[inline] -pub(crate) fn to_hash_type(ty: &Type) -> HashType { - let (ty, is_ref) = dereference_changed(ty); - - let ty = if is_ref { - syn::parse2(quote_spanned!( ty.span() => &'static #ty )).unwrap() - } else { - ty.clone() - }; - - HashType::from(ty) -} diff --git a/vendor/educe/src/trait_handlers/into/into_enum.rs b/vendor/educe/src/trait_handlers/into/into_enum.rs deleted file mode 100644 index dd4b1988..00000000 --- a/vendor/educe/src/trait_handlers/into/into_enum.rs +++ /dev/null @@ -1,224 +0,0 @@ -use std::collections::HashMap; - -use quote::{format_ident, quote}; -use syn::{Data, DeriveInput, Field, Fields, Ident, Meta, Path, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandlerMultiple, -}; -use crate::{panic, Trait}; - -pub(crate) struct IntoEnumHandler; - -impl TraitHandlerMultiple for IntoEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &[Meta], - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_types: true - } - .build_from_into_meta(meta)?; - - if let Data::Enum(data) = &ast.data { - let field_attributes: Vec<HashMap<usize, FieldAttribute>> = { - let mut map = Vec::new(); - - for variant in data.variants.iter() { - let mut field_map = HashMap::new(); - - let _ = TypeAttributeBuilder { - enable_types: false - } - .build_from_attributes(&variant.attrs, traits)?; - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_types: true - } - .build_from_attributes(&field.attrs, traits)?; - - for ty in field_attribute.types.keys() { - if !type_attribute.types.contains_key(ty) { - return Err(super::panic::no_into_impl(ty)); - } - } - - field_map.insert(index, field_attribute); - } - - map.push(field_map); - } - - map - }; - - for (target_ty, bound) in type_attribute.types { - let mut into_types: Vec<&Type> = Vec::new(); - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - type Variants<'a> = - Vec<(&'a Ident, bool, usize, Ident, &'a Type, Option<&'a Path>)>; - - let mut variants: Variants = Vec::new(); - - for (variant, field_attributes) in data.variants.iter().zip(field_attributes.iter()) - { - if let Fields::Unit = &variant.fields { - return Err(panic::trait_not_support_unit_variant( - meta[0].path().get_ident().unwrap(), - variant, - )); - } - - let (index, field, method) = { - let fields = &variant.fields; - - if fields.len() == 1 { - let field = fields.into_iter().next().unwrap(); - - let method = if let Some(field_attribute) = field_attributes.get(&0) { - if let Some(method) = field_attribute.types.get(&target_ty) { - method.as_ref() - } else { - None - } - } else { - None - }; - - (0usize, field, method) - } else { - let mut into_field: Option<(usize, &Field, Option<&Path>)> = None; - - for (index, field) in fields.iter().enumerate() { - if let Some(field_attribute) = field_attributes.get(&index) { - if let Some((key, method)) = - field_attribute.types.get_key_value(&target_ty) - { - if into_field.is_some() { - return Err(super::panic::multiple_into_fields(key)); - } - - into_field = Some((index, field, method.as_ref())); - } - } - } - - if into_field.is_none() { - // search the same type - for (index, field) in fields.iter().enumerate() { - let field_ty = super::common::to_hash_type(&field.ty); - - if target_ty.eq(&field_ty) { - if into_field.is_some() { - // multiple candidates - into_field = None; - - break; - } - - into_field = Some((index, field, None)); - } - } - } - - if let Some(into_field) = into_field { - into_field - } else { - return Err(super::panic::no_into_field(&target_ty)); - } - } - }; - - let (field_name, is_tuple): (Ident, bool) = match field.ident.as_ref() { - Some(ident) => (ident.clone(), false), - None => (format_ident!("_{}", index), true), - }; - - variants.push((&variant.ident, is_tuple, index, field_name, &field.ty, method)); - } - - if variants.is_empty() { - return Err(super::panic::no_into_field(&target_ty)); - } - - for (variant_ident, is_tuple, index, field_name, ty, method) in variants { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut body_token_stream = proc_macro2::TokenStream::new(); - - if let Some(method) = method { - body_token_stream.extend(quote!( #method(#field_name) )); - } else { - let field_ty = super::common::to_hash_type(ty); - - if target_ty.eq(&field_ty) { - body_token_stream.extend(quote!( #field_name )); - } else { - into_types.push(ty); - - body_token_stream - .extend(quote!( ::core::convert::Into::into(#field_name) )); - } - } - - if is_tuple { - for _ in 0..index { - pattern_token_stream.extend(quote!(_,)); - } - - pattern_token_stream.extend(quote!( #field_name, .. )); - - arms_token_stream.extend( - quote!( Self::#variant_ident ( #pattern_token_stream ) => #body_token_stream, ), - ); - } else { - pattern_token_stream.extend(quote!( #field_name, .. )); - - arms_token_stream.extend( - quote!( Self::#variant_ident { #pattern_token_stream } => #body_token_stream, ), - ); - } - } - - let ident = &ast.ident; - - let bound = bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::convert::Into<#target_ty>)).unwrap(), - &into_types, - &[], - ); - - // clone generics in order to not to affect other Into<T> implementations - let mut generics = ast.generics.clone(); - - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, _) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::convert::Into<#target_ty> for #ident #ty_generics #where_clause { - #[inline] - fn into(self) -> #target_ty { - match self { - #arms_token_stream - } - } - } - }); - } - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/into/into_struct.rs b/vendor/educe/src/trait_handlers/into/into_struct.rs deleted file mode 100644 index ea139485..00000000 --- a/vendor/educe/src/trait_handlers/into/into_struct.rs +++ /dev/null @@ -1,168 +0,0 @@ -use std::collections::HashMap; - -use quote::quote; -use syn::{Data, DeriveInput, Field, Meta, Path, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandlerMultiple, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub(crate) struct IntoStructHandler; - -impl TraitHandlerMultiple for IntoStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &[Meta], - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_types: true - } - .build_from_into_meta(meta)?; - - if let Data::Struct(data) = &ast.data { - let fields = &data.fields; - - let field_attributes: HashMap<usize, FieldAttribute> = { - let mut map = HashMap::new(); - - for (index, field) in fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_types: true - } - .build_from_attributes(&field.attrs, traits)?; - - for ty in field_attribute.types.keys() { - if !type_attribute.types.contains_key(ty) { - return Err(super::panic::no_into_impl(ty)); - } - } - - map.insert(index, field_attribute); - } - - map - }; - - for (target_ty, bound) in type_attribute.types { - let mut into_types: Vec<&Type> = Vec::new(); - - let mut into_token_stream = proc_macro2::TokenStream::new(); - - let (index, field, method) = { - let fields = &data.fields; - - if fields.len() == 1 { - let field = fields.into_iter().next().unwrap(); - - let method = if let Some(field_attribute) = field_attributes.get(&0) { - if let Some(method) = field_attribute.types.get(&target_ty) { - method.as_ref() - } else { - None - } - } else { - None - }; - - (0usize, field, method) - } else { - let mut into_field: Option<(usize, &Field, Option<&Path>)> = None; - - for (index, field) in fields.iter().enumerate() { - if let Some(field_attribute) = field_attributes.get(&index) { - if let Some((key, method)) = - field_attribute.types.get_key_value(&target_ty) - { - if into_field.is_some() { - return Err(super::panic::multiple_into_fields(key)); - } - - into_field = Some((index, field, method.as_ref())); - } - } - } - - if into_field.is_none() { - // search the same type - for (index, field) in fields.iter().enumerate() { - let field_ty = super::common::to_hash_type(&field.ty); - - if target_ty.eq(&field_ty) { - if into_field.is_some() { - // multiple candidates - into_field = None; - - break; - } - - into_field = Some((index, field, None)); - } - } - } - - if let Some(into_field) = into_field { - into_field - } else { - return Err(super::panic::no_into_field(&target_ty)); - } - } - }; - - let field_name = IdentOrIndex::from_ident_with_index(field.ident.as_ref(), index); - - if let Some(method) = method { - into_token_stream.extend(quote!( #method(self.#field_name) )); - } else { - let ty = &field.ty; - - let field_ty = super::common::to_hash_type(ty); - - if target_ty.eq(&field_ty) { - into_token_stream.extend(quote!( self.#field_name )); - } else { - into_types.push(ty); - - into_token_stream - .extend(quote!( ::core::convert::Into::into(self.#field_name) )); - } - } - - let ident = &ast.ident; - - let bound = bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::convert::Into<#target_ty>)).unwrap(), - &into_types, - &[], - ); - - // clone generics in order to not to affect other Into<T> implementations - let mut generics = ast.generics.clone(); - - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, _) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::convert::Into<#target_ty> for #ident #ty_generics #where_clause { - #[inline] - fn into(self) -> #target_ty { - #into_token_stream - } - } - }); - } - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/into/mod.rs b/vendor/educe/src/trait_handlers/into/mod.rs deleted file mode 100644 index 1f91777f..00000000 --- a/vendor/educe/src/trait_handlers/into/mod.rs +++ /dev/null @@ -1,34 +0,0 @@ -mod common; -mod into_enum; -mod into_struct; -mod models; -mod panic; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandlerMultiple; -use crate::Trait; - -pub(crate) struct IntoHandler; - -impl TraitHandlerMultiple for IntoHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &[Meta], - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => { - into_struct::IntoStructHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Enum(_) => { - into_enum::IntoEnumHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Union(_) => { - Err(crate::panic::trait_not_support_union(meta[0].path().get_ident().unwrap())) - }, - } - } -} diff --git a/vendor/educe/src/trait_handlers/into/models/field_attribute.rs b/vendor/educe/src/trait_handlers/into/models/field_attribute.rs deleted file mode 100644 index 44a7def8..00000000 --- a/vendor/educe/src/trait_handlers/into/models/field_attribute.rs +++ /dev/null @@ -1,152 +0,0 @@ -use std::collections::HashMap; - -use syn::{punctuated::Punctuated, Attribute, Meta, Path, Token}; - -use crate::{ - common::{path::meta_2_path, r#type::TypeWithPunctuatedMeta, tools::HashType}, - panic, Trait, -}; - -pub(crate) struct FieldAttribute { - pub(crate) types: HashMap<HashType, Option<Path>>, -} - -#[derive(Debug)] -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_types: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_into_meta(&self, meta: &[Meta]) -> syn::Result<FieldAttribute> { - debug_assert!(!meta.is_empty()); - - let mut types = HashMap::new(); - - for meta in meta { - debug_assert!(meta.path().is_ident("Into")); - - let correct_usage_for_into_attribute = { - let mut usage = vec![]; - - if self.enable_types { - usage.push(stringify!(#[educe(Into(type))])); - usage.push(stringify!(#[educe(Into(type, method(path_to_method)))])); - } - - usage - }; - - match meta { - Meta::Path(_) | Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_into_attribute, - )); - }, - Meta::List(list) => { - if !self.enable_types { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_into_attribute, - )); - } - - let TypeWithPunctuatedMeta { - ty, - list: result, - } = list.parse_args()?; - - let ty = super::super::common::to_hash_type(&ty); - - let mut method = None; - let mut method_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "method" { - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_into_attribute, - )); - } - } - - if types.contains_key(&ty) { - return Err(super::super::panic::reset_a_type(&ty)); - } - - types.insert(ty, method); - }, - } - } - - Ok(FieldAttribute { - types, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output: Option<FieldAttribute> = None; - - let mut v_meta = Vec::new(); - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Into { - v_meta.push(meta); - } - } - } - } - } - - if !v_meta.is_empty() { - output = Some(self.build_from_into_meta(&v_meta)?); - } - - Ok(output.unwrap_or_else(|| FieldAttribute { - types: HashMap::new() - })) - } -} diff --git a/vendor/educe/src/trait_handlers/into/models/mod.rs b/vendor/educe/src/trait_handlers/into/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/into/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/into/models/type_attribute.rs b/vendor/educe/src/trait_handlers/into/models/type_attribute.rs deleted file mode 100644 index 526e31e0..00000000 --- a/vendor/educe/src/trait_handlers/into/models/type_attribute.rs +++ /dev/null @@ -1,153 +0,0 @@ -use std::collections::HashMap; - -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{ - common::{bound::Bound, r#type::TypeWithPunctuatedMeta, tools::HashType}, - panic, Trait, -}; - -pub(crate) struct TypeAttribute { - pub(crate) types: HashMap<HashType, Bound>, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_types: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_into_meta(&self, meta: &[Meta]) -> syn::Result<TypeAttribute> { - debug_assert!(!meta.is_empty()); - - let mut types = HashMap::new(); - - for meta in meta { - debug_assert!(meta.path().is_ident("Into")); - - let correct_usage_for_into_attribute = { - let mut usage = vec![]; - - if self.enable_types { - usage.push(stringify!(#[educe(Into(type))])); - usage.push(stringify!(#[educe(Into(type, bound = false))])); - usage.push(stringify!(#[educe(Into(type, bound(where_predicates)))])); - } - - usage - }; - - match meta { - Meta::Path(_) | Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_into_attribute, - )); - }, - Meta::List(list) => { - if !self.enable_types { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_into_attribute, - )); - } - - let TypeWithPunctuatedMeta { - ty, - list: result, - } = list.parse_args()?; - - let ty = super::super::common::to_hash_type(&ty); - - let mut bound = Bound::Auto; - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_into_attribute, - )); - } - } - - if types.contains_key(&ty) { - return Err(super::super::panic::reset_a_type(&ty)); - } - - types.insert(ty, bound); - }, - } - } - - Ok(TypeAttribute { - types, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output: Option<TypeAttribute> = None; - - let mut v_meta = Vec::new(); - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Into { - v_meta.push(meta); - } - } - } - } - } - - if !v_meta.is_empty() { - output = Some(self.build_from_into_meta(&v_meta)?); - } - - Ok(output.unwrap_or(TypeAttribute { - types: HashMap::new() - })) - } -} diff --git a/vendor/educe/src/trait_handlers/into/panic.rs b/vendor/educe/src/trait_handlers/into/panic.rs deleted file mode 100644 index 95947fcd..00000000 --- a/vendor/educe/src/trait_handlers/into/panic.rs +++ /dev/null @@ -1,27 +0,0 @@ -use crate::common::tools::HashType; - -#[inline] -pub(crate) fn reset_a_type(ty: &HashType) -> syn::Error { - syn::Error::new(ty.span(), format!("the type `{ty}` is repeatedly set")) -} - -#[inline] -pub(crate) fn no_into_field(ty: &HashType) -> syn::Error { - syn::Error::new(ty.span(), format!("there is no field which is assigned for `Into<{ty}>`")) -} - -#[inline] -pub(crate) fn no_into_impl(ty: &HashType) -> syn::Error { - syn::Error::new( - ty.span(), - format!( - "if you want to impl `Into<{ty}>` for this type, you should write \ - `#[educe(Into({ty}))]` outside" - ), - ) -} - -#[inline] -pub(crate) fn multiple_into_fields(ty: &HashType) -> syn::Error { - syn::Error::new(ty.span(), format!("multiple fields are set for `Into<{ty}>`")) -} diff --git a/vendor/educe/src/trait_handlers/mod.rs b/vendor/educe/src/trait_handlers/mod.rs deleted file mode 100644 index d82242b1..00000000 --- a/vendor/educe/src/trait_handlers/mod.rs +++ /dev/null @@ -1,48 +0,0 @@ -use syn::{DeriveInput, Meta}; - -use crate::Trait; - -#[cfg(feature = "Clone")] -pub(crate) mod clone; -#[cfg(feature = "Copy")] -pub(crate) mod copy; -#[cfg(feature = "Debug")] -pub(crate) mod debug; -#[cfg(feature = "Default")] -pub(crate) mod default; -#[cfg(feature = "Deref")] -pub(crate) mod deref; -#[cfg(feature = "DerefMut")] -pub(crate) mod deref_mut; -#[cfg(feature = "Eq")] -pub(crate) mod eq; -#[cfg(feature = "Hash")] -pub(crate) mod hash; -#[cfg(feature = "Into")] -pub(crate) mod into; -#[cfg(feature = "Ord")] -pub(crate) mod ord; -#[cfg(feature = "PartialEq")] -pub(crate) mod partial_eq; -#[cfg(feature = "PartialOrd")] -pub(crate) mod partial_ord; - -pub(crate) trait TraitHandler { - #[allow(dead_code)] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()>; -} - -pub(crate) trait TraitHandlerMultiple { - #[allow(dead_code)] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &[Meta], - ) -> syn::Result<()>; -} diff --git a/vendor/educe/src/trait_handlers/ord/mod.rs b/vendor/educe/src/trait_handlers/ord/mod.rs deleted file mode 100644 index 89b2e15f..00000000 --- a/vendor/educe/src/trait_handlers/ord/mod.rs +++ /dev/null @@ -1,49 +0,0 @@ -mod models; -mod ord_enum; -mod ord_struct; -mod panic; - -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct OrdHandler; - -impl TraitHandler for OrdHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => { - ord_struct::OrdStructHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Enum(_) => { - ord_enum::OrdEnumHandler::trait_meta_handler(ast, token_stream, traits, meta) - }, - Data::Union(_) => { - Err(crate::panic::trait_not_support_union(meta.path().get_ident().unwrap())) - }, - } - } -} - -fn supertraits(#[allow(unused_variables)] traits: &[Trait]) -> Vec<proc_macro2::TokenStream> { - let mut supertraits = vec![]; - supertraits.push(quote! {::core::cmp::Eq}); - - // We mustn't add the PartialOrd bound to the educed PartialOrd impl. - // When we're educing PartialOrd we can leave it off the Ord impl too, - // since we *know* Self is going to be PartialOrd. - #[cfg(feature = "PartialOrd")] - if !traits.contains(&Trait::PartialOrd) { - supertraits.push(quote! {::core::cmp::PartialOrd}); - }; - - supertraits -} diff --git a/vendor/educe/src/trait_handlers/ord/models/field_attribute.rs b/vendor/educe/src/trait_handlers/ord/models/field_attribute.rs deleted file mode 100644 index 7b2dd969..00000000 --- a/vendor/educe/src/trait_handlers/ord/models/field_attribute.rs +++ /dev/null @@ -1,217 +0,0 @@ -use proc_macro2::Span; -use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Meta, Path, Token}; - -use crate::{ - common::{ - ident_bool::{meta_2_bool_allow_path, meta_name_value_2_bool}, - int::meta_2_isize, - path::meta_2_path, - }, - panic, - supported_traits::Trait, -}; - -pub(crate) struct FieldAttribute { - pub(crate) ignore: bool, - pub(crate) method: Option<Path>, - pub(crate) rank: isize, - pub(crate) rank_span: Option<Span>, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_ignore: bool, - pub(crate) enable_method: bool, - pub(crate) enable_rank: bool, - pub(crate) rank: isize, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_ord_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("Ord") || meta.path().is_ident("PartialOrd")); - - let mut ignore = false; - let mut method = None; - let mut rank = self.rank; - let mut rank_span = None; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_ignore { - usage.push(stringify!(#[educe(Ord = false)])); - usage.push(stringify!(#[educe(Ord(ignore))])); - } - - if self.enable_method { - usage.push(stringify!(#[educe(Ord(method(path_to_method)))])); - } - - if self.enable_rank { - usage.push(stringify!(#[educe(Ord(rank = integer))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::NameValue(name_value) => { - if self.enable_ignore { - ignore = !meta_name_value_2_bool(name_value)?; - } else { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut ignore_is_set = false; - let mut method_is_set = false; - let mut rank_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "ignore" => { - if !self.enable_ignore { - return Ok(false); - } - - let v = meta_2_bool_allow_path(&meta)?; - - if ignore_is_set { - return Err(panic::parameter_reset(ident)); - } - - ignore_is_set = true; - - ignore = v; - - return Ok(true); - }, - "method" => { - if !self.enable_method { - return Ok(false); - } - - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - }, - "rank" => { - if !self.enable_rank { - return Ok(false); - } - - let v = meta_2_isize(&meta)?; - - if rank_is_set { - return Err(panic::parameter_reset(ident)); - } - - rank_is_set = true; - - rank = v; - rank_span = Some(meta.span()); - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - ignore, - method, - rank, - rank_span, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Ord { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_ord_meta(&meta)?); - } - - #[cfg(feature = "PartialOrd")] - if traits.contains(&Trait::PartialOrd) && t == Trait::PartialOrd { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_ord_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - ignore: false, - method: None, - rank: self.rank, - rank_span: None, - })) - } -} diff --git a/vendor/educe/src/trait_handlers/ord/models/mod.rs b/vendor/educe/src/trait_handlers/ord/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/ord/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/ord/models/type_attribute.rs b/vendor/educe/src/trait_handlers/ord/models/type_attribute.rs deleted file mode 100644 index 55054297..00000000 --- a/vendor/educe/src/trait_handlers/ord/models/type_attribute.rs +++ /dev/null @@ -1,149 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{common::bound::Bound, panic, Trait}; - -pub(crate) struct TypeAttribute { - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_ord_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("Ord") || meta.path().is_ident("PartialOrd")); - - let mut bound = Bound::Auto; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(Ord)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(Ord(bound(where_predicates)))])); - usage.push(stringify!(#[educe(Ord(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::Ord { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_ord_meta(&meta)?); - } - - #[cfg(feature = "PartialOrd")] - if traits.contains(&Trait::PartialOrd) && t == Trait::PartialOrd { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_ord_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/ord/ord_enum.rs b/vendor/educe/src/trait_handlers/ord/ord_enum.rs deleted file mode 100644 index 0edcb89c..00000000 --- a/vendor/educe/src/trait_handlers/ord/ord_enum.rs +++ /dev/null @@ -1,283 +0,0 @@ -use std::collections::BTreeMap; - -use quote::{format_ident, quote}; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Fields, Ident, Meta, Path, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::tools::DiscriminantType, Trait}; - -pub(crate) struct OrdEnumHandler; - -impl TraitHandler for OrdEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_ord_meta(meta)?; - - let mut ord_types: Vec<&Type> = Vec::new(); - - let mut cmp_token_stream = proc_macro2::TokenStream::new(); - - let discriminant_type = DiscriminantType::from_ast(ast)?; - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - let mut all_unit = true; - - if let Data::Enum(data) = &ast.data { - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, enable_bound: false - } - .build_from_attributes(&variant.attrs, traits)?; - - let variant_ident = &variant.ident; - - let built_in_cmp: Path = syn::parse2(quote!(::core::cmp::Ord::cmp)).unwrap(); - - match &variant.fields { - Fields::Unit => { - arms_token_stream.extend(quote! { - Self::#variant_ident => { - return ::core::cmp::Ordering::Equal; - } - }); - }, - Fields::Named(_) => { - all_unit = false; - - let mut pattern_self_token_stream = proc_macro2::TokenStream::new(); - let mut pattern_other_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - let mut fields: BTreeMap<isize, (&Field, Ident, Ident, FieldAttribute)> = - BTreeMap::new(); - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - enable_rank: true, - rank: isize::MIN + index as isize, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_var_self = format_ident!("_s_{}", field_name_real); - let field_name_var_other = format_ident!("_o_{}", field_name_real); - - if field_attribute.ignore { - pattern_self_token_stream.extend(quote!(#field_name_real: _,)); - pattern_other_token_stream.extend(quote!(#field_name_real: _,)); - - continue; - } - - pattern_self_token_stream - .extend(quote!(#field_name_real: #field_name_var_self,)); - pattern_other_token_stream - .extend(quote!(#field_name_real: #field_name_var_other,)); - - let rank = field_attribute.rank; - - if fields.contains_key(&rank) { - return Err(super::panic::reuse_a_rank( - field_attribute.rank_span.unwrap_or_else(|| field.span()), - rank, - )); - } - - fields.insert( - rank, - (field, field_name_var_self, field_name_var_other, field_attribute), - ); - } - - for (field, field_name_var_self, field_name_var_other, field_attribute) in - fields.values() - { - let cmp = field_attribute.method.as_ref().unwrap_or_else(|| { - ord_types.push(&field.ty); - - &built_in_cmp - }); - - block_token_stream.extend(quote! { - match #cmp(#field_name_var_self, #field_name_var_other) { - ::core::cmp::Ordering::Equal => (), - ::core::cmp::Ordering::Greater => return ::core::cmp::Ordering::Greater, - ::core::cmp::Ordering::Less => return ::core::cmp::Ordering::Less, - } - }); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident { #pattern_self_token_stream } => { - if let Self::#variant_ident { #pattern_other_token_stream } = other { - #block_token_stream - } - } - }); - }, - Fields::Unnamed(_) => { - all_unit = false; - - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut pattern2_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - let mut fields: BTreeMap<isize, (&Field, Ident, Ident, FieldAttribute)> = - BTreeMap::new(); - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - enable_rank: true, - rank: isize::MIN + index as isize, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_var_self = format_ident!("_{}", index); - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(_,)); - pattern2_token_stream.extend(quote!(_,)); - - continue; - } - - let field_name_var_other = format_ident!("_{}", field_name_var_self); - - pattern_token_stream.extend(quote!(#field_name_var_self,)); - pattern2_token_stream.extend(quote!(#field_name_var_other,)); - - let rank = field_attribute.rank; - - if fields.contains_key(&rank) { - return Err(super::panic::reuse_a_rank( - field_attribute.rank_span.unwrap_or_else(|| field.span()), - rank, - )); - } - - fields.insert( - rank, - (field, field_name_var_self, field_name_var_other, field_attribute), - ); - } - - for (field, field_name, field_name2, field_attribute) in fields.values() { - let cmp = field_attribute.method.as_ref().unwrap_or_else(|| { - ord_types.push(&field.ty); - - &built_in_cmp - }); - - block_token_stream.extend(quote! { - match #cmp(#field_name, #field_name2) { - ::core::cmp::Ordering::Equal => (), - ::core::cmp::Ordering::Greater => return ::core::cmp::Ordering::Greater, - ::core::cmp::Ordering::Less => return ::core::cmp::Ordering::Less, - } - }); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => { - if let Self::#variant_ident ( #pattern2_token_stream ) = other { - #block_token_stream - } - } - }); - }, - } - } - } - - if arms_token_stream.is_empty() { - cmp_token_stream.extend(quote!(::core::cmp::Ordering::Equal)); - } else { - let discriminant_cmp = quote! { - unsafe { - ::core::cmp::Ord::cmp(&*<*const _>::from(self).cast::<#discriminant_type>(), &*<*const _>::from(other).cast::<#discriminant_type>()) - } - }; - - cmp_token_stream.extend(if all_unit { - quote! { - match #discriminant_cmp { - ::core::cmp::Ordering::Equal => ::core::cmp::Ordering::Equal, - ::core::cmp::Ordering::Greater => ::core::cmp::Ordering::Greater, - ::core::cmp::Ordering::Less => ::core::cmp::Ordering::Less, - } - } - } else { - quote! { - match #discriminant_cmp { - ::core::cmp::Ordering::Equal => { - match self { - #arms_token_stream - } - - ::core::cmp::Ordering::Equal - }, - ::core::cmp::Ordering::Greater => ::core::cmp::Ordering::Greater, - ::core::cmp::Ordering::Less => ::core::cmp::Ordering::Less, - } - } - }); - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::Ord)).unwrap(), - &ord_types, - &crate::trait_handlers::ord::supertraits(traits), - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::Ord for #ident #ty_generics #where_clause { - #[inline] - fn cmp(&self, other: &Self) -> ::core::cmp::Ordering { - #cmp_token_stream - } - } - }); - - #[cfg(feature = "PartialOrd")] - if traits.contains(&Trait::PartialOrd) { - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialOrd for #ident #ty_generics #where_clause { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> { - Some(::core::cmp::Ord::cmp(self, other)) - } - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/ord/ord_struct.rs b/vendor/educe/src/trait_handlers/ord/ord_struct.rs deleted file mode 100644 index fc6c170a..00000000 --- a/vendor/educe/src/trait_handlers/ord/ord_struct.rs +++ /dev/null @@ -1,123 +0,0 @@ -use std::collections::BTreeMap; - -use quote::quote; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Meta, Path, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub(crate) struct OrdStructHandler; - -impl TraitHandler for OrdStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_ord_meta(meta)?; - - let mut ord_types: Vec<&Type> = Vec::new(); - - let mut cmp_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - let mut fields: BTreeMap<isize, (usize, &Field, FieldAttribute)> = BTreeMap::new(); - - for (index, field) in data.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - enable_rank: true, - rank: isize::MIN + index as isize, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - continue; - } - - let rank = field_attribute.rank; - - if fields.contains_key(&rank) { - return Err(super::panic::reuse_a_rank( - field_attribute.rank_span.unwrap_or_else(|| field.span()), - rank, - )); - } - - fields.insert(rank, (index, field, field_attribute)); - } - - let built_in_cmp: Path = syn::parse2(quote!(::core::cmp::Ord::cmp)).unwrap(); - - for (index, field, field_attribute) in fields.values() { - let field_name = IdentOrIndex::from_ident_with_index(field.ident.as_ref(), *index); - - let cmp = field_attribute.method.as_ref().unwrap_or_else(|| { - ord_types.push(&field.ty); - - &built_in_cmp - }); - - cmp_token_stream.extend(quote! { - match #cmp(&self.#field_name, &other.#field_name) { - ::core::cmp::Ordering::Equal => (), - ::core::cmp::Ordering::Greater => return ::core::cmp::Ordering::Greater, - ::core::cmp::Ordering::Less => return ::core::cmp::Ordering::Less, - } - }); - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::Ord)).unwrap(), - &ord_types, - &crate::trait_handlers::ord::supertraits(traits), - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::Ord for #ident #ty_generics #where_clause { - #[inline] - fn cmp(&self, other: &Self) -> ::core::cmp::Ordering { - #cmp_token_stream - - ::core::cmp::Ordering::Equal - } - } - }); - - #[cfg(feature = "PartialOrd")] - if traits.contains(&Trait::PartialOrd) { - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialOrd for #ident #ty_generics #where_clause { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> { - Some(::core::cmp::Ord::cmp(self, other)) - } - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/ord/panic.rs b/vendor/educe/src/trait_handlers/ord/panic.rs deleted file mode 100644 index 839f3e88..00000000 --- a/vendor/educe/src/trait_handlers/ord/panic.rs +++ /dev/null @@ -1,6 +0,0 @@ -use proc_macro2::Span; - -#[inline] -pub(crate) fn reuse_a_rank(span: Span, rank: isize) -> syn::Error { - syn::Error::new(span, format!("the rank `{rank}` is repeatedly used")) -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/mod.rs b/vendor/educe/src/trait_handlers/partial_eq/mod.rs deleted file mode 100644 index 2bf7c727..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/mod.rs +++ /dev/null @@ -1,43 +0,0 @@ -mod models; -mod panic; -mod partial_eq_enum; -mod partial_eq_struct; -mod partial_eq_union; - -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct PartialEqHandler; - -impl TraitHandler for PartialEqHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - match ast.data { - Data::Struct(_) => partial_eq_struct::PartialEqStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => partial_eq_enum::PartialEqEnumHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Union(_) => partial_eq_union::PartialEqUnionHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - } - } -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/models/field_attribute.rs b/vendor/educe/src/trait_handlers/partial_eq/models/field_attribute.rs deleted file mode 100644 index 4b67aba5..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/models/field_attribute.rs +++ /dev/null @@ -1,181 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Path, Token}; - -use crate::{ - common::{ - ident_bool::{meta_2_bool_allow_path, meta_name_value_2_bool}, - path::meta_2_path, - }, - panic, - supported_traits::Trait, -}; - -pub(crate) struct FieldAttribute { - pub(crate) ignore: bool, - pub(crate) method: Option<Path>, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_ignore: bool, - pub(crate) enable_method: bool, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_partial_eq_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("PartialEq") || meta.path().is_ident("Eq")); - - let mut ignore = false; - let mut method = None; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_ignore { - usage.push(stringify!(#[educe(PartialEq = false)])); - usage.push(stringify!(#[educe(PartialEq(ignore))])); - } - - if self.enable_method { - usage.push(stringify!(#[educe(PartialEq(method(path_to_method)))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::NameValue(name_value) => { - if self.enable_ignore { - ignore = !meta_name_value_2_bool(name_value)?; - } else { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut ignore_is_set = false; - let mut method_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "ignore" => { - if !self.enable_ignore { - return Ok(false); - } - - let v = meta_2_bool_allow_path(&meta)?; - - if ignore_is_set { - return Err(panic::parameter_reset(ident)); - } - - ignore_is_set = true; - - ignore = v; - - return Ok(true); - }, - "method" => { - if !self.enable_method { - return Ok(false); - } - - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - ignore, - method, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::PartialEq { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_partial_eq_meta(&meta)?); - } - - #[cfg(feature = "Eq")] - if traits.contains(&Trait::Eq) && t == Trait::Eq { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_partial_eq_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - ignore: false, method: None - })) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/models/mod.rs b/vendor/educe/src/trait_handlers/partial_eq/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/partial_eq/models/type_attribute.rs b/vendor/educe/src/trait_handlers/partial_eq/models/type_attribute.rs deleted file mode 100644 index 83779975..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/models/type_attribute.rs +++ /dev/null @@ -1,163 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{ - common::{bound::Bound, unsafe_punctuated_meta::UnsafePunctuatedMeta}, - panic, Trait, -}; - -pub(crate) struct TypeAttribute { - pub(crate) has_unsafe: bool, - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_unsafe: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_partial_eq_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("PartialEq") || meta.path().is_ident("Eq")); - - let mut has_unsafe = false; - let mut bound = Bound::Auto; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(PartialEq)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(PartialEq(bound(where_predicates)))])); - usage.push(stringify!(#[educe(PartialEq(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::List(list) => { - let result = if self.enable_unsafe { - let result: UnsafePunctuatedMeta = list.parse_args()?; - - has_unsafe = result.has_unsafe; - - result.list - } else { - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)? - }; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - has_unsafe, - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::PartialEq { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_partial_eq_meta(&meta)?); - } - - #[cfg(feature = "Eq")] - if traits.contains(&Trait::Eq) && t == Trait::Eq { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_partial_eq_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - has_unsafe: false, bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/panic.rs b/vendor/educe/src/trait_handlers/partial_eq/panic.rs deleted file mode 100644 index 69d001be..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/panic.rs +++ /dev/null @@ -1,22 +0,0 @@ -use quote::ToTokens; -use syn::{spanned::Spanned, Meta}; - -#[inline] -pub(crate) fn union_without_unsafe(meta: &Meta) -> syn::Error { - let mut s = meta.into_token_stream().to_string(); - - match s.len() { - 9 => s.push_str("(unsafe)"), - 11 => s.insert_str(10, "unsafe"), - _ => unreachable!(), - } - - syn::Error::new( - meta.span(), - format!( - "a union's `PartialEq` implementation is not precise, because it ignores the type of \ - fields\n* If your union doesn't care about that, use `#[educe({s})]` to implement \ - the `PartialEq` trait for it." - ), - ) -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/partial_eq_enum.rs b/vendor/educe/src/trait_handlers/partial_eq/partial_eq_enum.rs deleted file mode 100644 index d000f35c..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/partial_eq_enum.rs +++ /dev/null @@ -1,218 +0,0 @@ -use quote::{format_ident, quote}; -use syn::{Data, DeriveInput, Fields, Meta, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::Trait; - -pub(crate) struct PartialEqEnumHandler; - -impl TraitHandler for PartialEqEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = - TypeAttributeBuilder { - enable_flag: true, enable_unsafe: false, enable_bound: true - } - .build_from_partial_eq_meta(meta)?; - - let mut partial_eq_types: Vec<&Type> = Vec::new(); - - let mut eq_token_stream = proc_macro2::TokenStream::new(); - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Enum(data) = &ast.data { - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, - enable_unsafe: false, - enable_bound: false, - } - .build_from_attributes(&variant.attrs, traits)?; - - let variant_ident = &variant.ident; - - match &variant.fields { - Fields::Unit => { - arms_token_stream.extend(quote! { - Self::#variant_ident => { - if let Self::#variant_ident = other { - // same - } else { - return false; - } - } - }); - }, - Fields::Named(_) => { - let mut pattern_self_token_stream = proc_macro2::TokenStream::new(); - let mut pattern_other_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - for field in variant.fields.iter() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_var_self = format_ident!("_s_{}", field_name_real); - let field_name_var_other = format_ident!("_o_{}", field_name_real); - - if field_attribute.ignore { - pattern_self_token_stream.extend(quote!(#field_name_real: _,)); - pattern_other_token_stream.extend(quote!(#field_name_real: _,)); - - continue; - } - - pattern_self_token_stream - .extend(quote!(#field_name_real: #field_name_var_self,)); - pattern_other_token_stream - .extend(quote!(#field_name_real: #field_name_var_other,)); - - if let Some(method) = field_attribute.method { - block_token_stream.extend(quote! { - if !#method(#field_name_var_self, #field_name_var_other) { - return false; - } - }); - } else { - let ty = &field.ty; - - partial_eq_types.push(ty); - - block_token_stream.extend(quote! { - if ::core::cmp::PartialEq::ne(#field_name_var_self, #field_name_var_other) { - return false; - } - }); - } - } - - arms_token_stream.extend(quote! { - Self::#variant_ident { #pattern_self_token_stream } => { - if let Self::#variant_ident { #pattern_other_token_stream } = other { - #block_token_stream - } else { - return false; - } - } - }); - }, - Fields::Unnamed(_) => { - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut pattern2_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(_,)); - pattern2_token_stream.extend(quote!(_,)); - - continue; - } - - let field_name_var_self = format_ident!("_{}", index); - - let field_name_var_other = format_ident!("_{}", field_name_var_self); - - pattern_token_stream.extend(quote!(#field_name_var_self,)); - pattern2_token_stream.extend(quote!(#field_name_var_other,)); - - if let Some(method) = field_attribute.method { - block_token_stream.extend(quote! { - if !#method(#field_name_var_self, #field_name_var_other) { - return false; - } - }); - } else { - let ty = &field.ty; - - partial_eq_types.push(ty); - - block_token_stream.extend(quote! { - if ::core::cmp::PartialEq::ne(#field_name_var_self, #field_name_var_other) { - return false; - } - }); - } - } - - arms_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => { - if let Self::#variant_ident ( #pattern2_token_stream ) = other { - #block_token_stream - } else { - return false; - } - } - }); - }, - } - } - } - - if !arms_token_stream.is_empty() { - eq_token_stream.extend(quote! { - match self { - #arms_token_stream - } - }); - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::PartialEq)).unwrap(), - &partial_eq_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialEq for #ident #ty_generics #where_clause { - #[inline] - fn eq(&self, other: &Self) -> bool { - #eq_token_stream - - true - } - } - }); - - #[cfg(feature = "Eq")] - if traits.contains(&Trait::Eq) { - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::Eq for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/partial_eq_struct.rs b/vendor/educe/src/trait_handlers/partial_eq/partial_eq_struct.rs deleted file mode 100644 index 7394b8b1..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/partial_eq_struct.rs +++ /dev/null @@ -1,103 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Meta, Type}; - -use super::{ - models::{FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub(crate) struct PartialEqStructHandler; - -impl TraitHandler for PartialEqStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = - TypeAttributeBuilder { - enable_flag: true, enable_unsafe: false, enable_bound: true - } - .build_from_partial_eq_meta(meta)?; - - let mut partial_eq_types: Vec<&Type> = Vec::new(); - - let mut eq_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - for (index, field) in data.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - continue; - } - - let field_name = IdentOrIndex::from_ident_with_index(field.ident.as_ref(), index); - - if let Some(method) = field_attribute.method { - eq_token_stream.extend(quote! { - if !#method(&self.#field_name, &other.#field_name) { - return false; - } - }); - } else { - let ty = &field.ty; - - partial_eq_types.push(ty); - - eq_token_stream.extend(quote! { - if ::core::cmp::PartialEq::ne(&self.#field_name, &other.#field_name) { - return false; - } - }); - } - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::PartialEq)).unwrap(), - &partial_eq_types, - &[], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialEq for #ident #ty_generics #where_clause { - #[inline] - fn eq(&self, other: &Self) -> bool { - #eq_token_stream - - true - } - } - }); - - #[cfg(feature = "Eq")] - if traits.contains(&Trait::Eq) { - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::Eq for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_eq/partial_eq_union.rs b/vendor/educe/src/trait_handlers/partial_eq/partial_eq_union.rs deleted file mode 100644 index 80ac2b73..00000000 --- a/vendor/educe/src/trait_handlers/partial_eq/partial_eq_union.rs +++ /dev/null @@ -1,63 +0,0 @@ -use quote::quote; -use syn::{Data, DeriveInput, Meta}; - -use super::models::{FieldAttributeBuilder, TypeAttributeBuilder}; -use crate::{supported_traits::Trait, trait_handlers::TraitHandler}; - -pub(crate) struct PartialEqUnionHandler; - -impl TraitHandler for PartialEqUnionHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = - TypeAttributeBuilder { - enable_flag: true, enable_unsafe: true, enable_bound: false - } - .build_from_partial_eq_meta(meta)?; - - if !type_attribute.has_unsafe { - return Err(super::panic::union_without_unsafe(meta)); - } - - if let Data::Union(data) = &ast.data { - for field in data.fields.named.iter() { - let _ = FieldAttributeBuilder { - enable_ignore: false, enable_method: false - } - .build_from_attributes(&field.attrs, traits)?; - } - } - - let ident = &ast.ident; - - let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialEq for #ident #ty_generics #where_clause { - #[inline] - fn eq(&self, other: &Self) -> bool { - let size = ::core::mem::size_of::<Self>(); - let self_data = unsafe { ::core::slice::from_raw_parts(self as *const Self as *const u8, size) }; - let other_data = unsafe { ::core::slice::from_raw_parts(other as *const Self as *const u8, size) }; - - ::core::cmp::PartialEq::eq(self_data, other_data) - } - } - }); - - #[cfg(feature = "Eq")] - if traits.contains(&Trait::Eq) { - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::Eq for #ident #ty_generics #where_clause { - } - }); - } - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_ord/mod.rs b/vendor/educe/src/trait_handlers/partial_ord/mod.rs deleted file mode 100644 index c69ff200..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/mod.rs +++ /dev/null @@ -1,58 +0,0 @@ -mod models; -mod panic; -mod partial_ord_enum; -mod partial_ord_struct; - -use models::TypeAttributeBuilder; -use syn::{Data, DeriveInput, Meta}; - -use super::TraitHandler; -use crate::Trait; - -pub(crate) struct PartialOrdHandler; - -impl TraitHandler for PartialOrdHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - #[cfg(feature = "Ord")] - let contains_ord = traits.contains(&Trait::Ord); - - #[cfg(not(feature = "Ord"))] - let contains_ord = false; - - // if `contains_ord` is true, the implementation is handled by the `Ord` attribute - if contains_ord { - let _ = TypeAttributeBuilder { - enable_flag: true, enable_bound: false - } - .build_from_partial_ord_meta(meta)?; - - // field attributes is also handled by the `Ord` attribute - - Ok(()) - } else { - match ast.data { - Data::Struct(_) => partial_ord_struct::PartialOrdStructHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Enum(_) => partial_ord_enum::PartialOrdEnumHandler::trait_meta_handler( - ast, - token_stream, - traits, - meta, - ), - Data::Union(_) => { - Err(crate::panic::trait_not_support_union(meta.path().get_ident().unwrap())) - }, - } - } - } -} diff --git a/vendor/educe/src/trait_handlers/partial_ord/models/field_attribute.rs b/vendor/educe/src/trait_handlers/partial_ord/models/field_attribute.rs deleted file mode 100644 index be455ba1..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/models/field_attribute.rs +++ /dev/null @@ -1,208 +0,0 @@ -use proc_macro2::Span; -use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Meta, Path, Token}; - -use crate::{ - common::{ - ident_bool::{meta_2_bool_allow_path, meta_name_value_2_bool}, - int::meta_2_isize, - path::meta_2_path, - }, - panic, - supported_traits::Trait, -}; - -pub(crate) struct FieldAttribute { - pub(crate) ignore: bool, - pub(crate) method: Option<Path>, - pub(crate) rank: isize, - pub(crate) rank_span: Option<Span>, -} - -pub(crate) struct FieldAttributeBuilder { - pub(crate) enable_ignore: bool, - pub(crate) enable_method: bool, - pub(crate) enable_rank: bool, - pub(crate) rank: isize, -} - -impl FieldAttributeBuilder { - pub(crate) fn build_from_partial_ord_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> { - debug_assert!(meta.path().is_ident("PartialOrd")); - - let mut ignore = false; - let mut method = None; - let mut rank = self.rank; - let mut rank_span = None; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_ignore { - usage.push(stringify!(#[educe(PartialOrd = false)])); - usage.push(stringify!(#[educe(PartialOrd(ignore))])); - } - - if self.enable_method { - usage.push(stringify!(#[educe(PartialOrd(method(path_to_method)))])); - } - - if self.enable_rank { - usage.push(stringify!(#[educe(PartialOrd(rank = integer))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::NameValue(name_value) => { - if self.enable_ignore { - ignore = !meta_name_value_2_bool(name_value)?; - } else { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut ignore_is_set = false; - let mut method_is_set = false; - let mut rank_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - match ident.to_string().as_str() { - "ignore" => { - if !self.enable_ignore { - return Ok(false); - } - - let v = meta_2_bool_allow_path(&meta)?; - - if ignore_is_set { - return Err(panic::parameter_reset(ident)); - } - - ignore_is_set = true; - - ignore = v; - - return Ok(true); - }, - "method" => { - if !self.enable_method { - return Ok(false); - } - - let v = meta_2_path(&meta)?; - - if method_is_set { - return Err(panic::parameter_reset(ident)); - } - - method_is_set = true; - - method = Some(v); - - return Ok(true); - }, - "rank" => { - if !self.enable_rank { - return Ok(false); - } - - let v = meta_2_isize(&meta)?; - - if rank_is_set { - return Err(panic::parameter_reset(ident)); - } - - rank_is_set = true; - - rank = v; - rank_span = Some(meta.span()); - - return Ok(true); - }, - _ => (), - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(FieldAttribute { - ignore, - method, - rank, - rank_span, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<FieldAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::PartialOrd { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_partial_ord_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(FieldAttribute { - ignore: false, - method: None, - rank: self.rank, - rank_span: None, - })) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_ord/models/mod.rs b/vendor/educe/src/trait_handlers/partial_ord/models/mod.rs deleted file mode 100644 index 1e4681f8..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/models/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod field_attribute; -mod type_attribute; - -pub(crate) use field_attribute::*; -pub(crate) use type_attribute::*; diff --git a/vendor/educe/src/trait_handlers/partial_ord/models/type_attribute.rs b/vendor/educe/src/trait_handlers/partial_ord/models/type_attribute.rs deleted file mode 100644 index 5c318c4b..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/models/type_attribute.rs +++ /dev/null @@ -1,140 +0,0 @@ -use syn::{punctuated::Punctuated, Attribute, Meta, Token}; - -use crate::{common::bound::Bound, panic, Trait}; - -pub(crate) struct TypeAttribute { - pub(crate) bound: Bound, -} - -#[derive(Debug)] -pub(crate) struct TypeAttributeBuilder { - pub(crate) enable_flag: bool, - pub(crate) enable_bound: bool, -} - -impl TypeAttributeBuilder { - pub(crate) fn build_from_partial_ord_meta(&self, meta: &Meta) -> syn::Result<TypeAttribute> { - debug_assert!(meta.path().is_ident("PartialOrd")); - - let mut bound = Bound::Auto; - - let correct_usage_for_partial_eq_attribute = { - let mut usage = vec![]; - - if self.enable_flag { - usage.push(stringify!(#[educe(PartialOrd)])); - } - - if self.enable_bound { - usage.push(stringify!(#[educe(PartialOrd(bound(where_predicates)))])); - usage.push(stringify!(#[educe(PartialOrd(bound = false))])); - } - - usage - }; - - match meta { - Meta::Path(_) => { - if !self.enable_flag { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - }, - Meta::NameValue(_) => { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - }, - Meta::List(list) => { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - let mut bound_is_set = false; - - let mut handler = |meta: Meta| -> syn::Result<bool> { - if let Some(ident) = meta.path().get_ident() { - if ident == "bound" { - if !self.enable_bound { - return Ok(false); - } - - let v = Bound::from_meta(&meta)?; - - if bound_is_set { - return Err(panic::parameter_reset(ident)); - } - - bound_is_set = true; - - bound = v; - - return Ok(true); - } - } - - Ok(false) - }; - - for p in result { - if !handler(p)? { - return Err(panic::attribute_incorrect_format( - meta.path().get_ident().unwrap(), - &correct_usage_for_partial_eq_attribute, - )); - } - } - }, - } - - Ok(TypeAttribute { - bound, - }) - } - - pub(crate) fn build_from_attributes( - &self, - attributes: &[Attribute], - traits: &[Trait], - ) -> syn::Result<TypeAttribute> { - let mut output = None; - - for attribute in attributes.iter() { - let path = attribute.path(); - - if path.is_ident("educe") { - if let Meta::List(list) = &attribute.meta { - let result = - list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; - - for meta in result { - let path = meta.path(); - - let t = match Trait::from_path(path) { - Some(t) => t, - None => return Err(panic::unsupported_trait(meta.path())), - }; - - if !traits.contains(&t) { - return Err(panic::trait_not_used(path.get_ident().unwrap())); - } - - if t == Trait::PartialOrd { - if output.is_some() { - return Err(panic::reuse_a_trait(path.get_ident().unwrap())); - } - - output = Some(self.build_from_partial_ord_meta(&meta)?); - } - } - } - } - } - - Ok(output.unwrap_or(TypeAttribute { - bound: Bound::Auto - })) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_ord/panic.rs b/vendor/educe/src/trait_handlers/partial_ord/panic.rs deleted file mode 100644 index 839f3e88..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/panic.rs +++ /dev/null @@ -1,6 +0,0 @@ -use proc_macro2::Span; - -#[inline] -pub(crate) fn reuse_a_rank(span: Span, rank: isize) -> syn::Error { - syn::Error::new(span, format!("the rank `{rank}` is repeatedly used")) -} diff --git a/vendor/educe/src/trait_handlers/partial_ord/partial_ord_enum.rs b/vendor/educe/src/trait_handlers/partial_ord/partial_ord_enum.rs deleted file mode 100644 index c41036ff..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/partial_ord_enum.rs +++ /dev/null @@ -1,276 +0,0 @@ -use std::collections::BTreeMap; - -use quote::{format_ident, quote}; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Fields, Ident, Meta, Path, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::tools::DiscriminantType, Trait}; - -pub(crate) struct PartialOrdEnumHandler; - -impl TraitHandler for PartialOrdEnumHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_partial_ord_meta(meta)?; - - let mut partial_ord_types: Vec<&Type> = Vec::new(); - - let mut partial_cmp_token_stream = proc_macro2::TokenStream::new(); - - let discriminant_type = DiscriminantType::from_ast(ast)?; - - let mut arms_token_stream = proc_macro2::TokenStream::new(); - - let mut all_unit = true; - - if let Data::Enum(data) = &ast.data { - for variant in data.variants.iter() { - let _ = TypeAttributeBuilder { - enable_flag: false, enable_bound: false - } - .build_from_attributes(&variant.attrs, traits)?; - - let variant_ident = &variant.ident; - - let built_in_partial_cmp: Path = - syn::parse2(quote!(::core::cmp::PartialOrd::partial_cmp)).unwrap(); - - match &variant.fields { - Fields::Unit => { - arms_token_stream.extend(quote! { - Self::#variant_ident => { - return Some(::core::cmp::Ordering::Equal); - } - }); - }, - Fields::Named(_) => { - all_unit = false; - - let mut pattern_self_token_stream = proc_macro2::TokenStream::new(); - let mut pattern_other_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - let mut fields: BTreeMap<isize, (&Field, Ident, Ident, FieldAttribute)> = - BTreeMap::new(); - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - enable_rank: true, - rank: isize::MIN + index as isize, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_real = field.ident.as_ref().unwrap(); - let field_name_var_self = format_ident!("_s_{}", field_name_real); - let field_name_var_other = format_ident!("_o_{}", field_name_real); - - if field_attribute.ignore { - pattern_self_token_stream.extend(quote!(#field_name_real: _,)); - pattern_other_token_stream.extend(quote!(#field_name_real: _,)); - - continue; - } - - pattern_self_token_stream - .extend(quote!(#field_name_real: #field_name_var_self,)); - pattern_other_token_stream - .extend(quote!(#field_name_real: #field_name_var_other,)); - - let rank = field_attribute.rank; - - if fields.contains_key(&rank) { - return Err(super::panic::reuse_a_rank( - field_attribute.rank_span.unwrap_or_else(|| field.span()), - rank, - )); - } - - fields.insert( - rank, - (field, field_name_var_self, field_name_var_other, field_attribute), - ); - } - - for (field, field_name_var_self, field_name_var_other, field_attribute) in - fields.values() - { - let partial_cmp = - field_attribute.method.as_ref().unwrap_or_else(|| { - partial_ord_types.push(&field.ty); - - &built_in_partial_cmp - }); - - block_token_stream.extend(quote! { - match #partial_cmp(#field_name_var_self, #field_name_var_other) { - Some(::core::cmp::Ordering::Equal) => (), - Some(::core::cmp::Ordering::Greater) => return Some(::core::cmp::Ordering::Greater), - Some(::core::cmp::Ordering::Less) => return Some(::core::cmp::Ordering::Less), - None => return None, - } - }); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident { #pattern_self_token_stream } => { - if let Self::#variant_ident { #pattern_other_token_stream } = other { - #block_token_stream - } - } - }); - }, - Fields::Unnamed(_) => { - all_unit = false; - - let mut pattern_token_stream = proc_macro2::TokenStream::new(); - let mut pattern2_token_stream = proc_macro2::TokenStream::new(); - let mut block_token_stream = proc_macro2::TokenStream::new(); - - let mut fields: BTreeMap<isize, (&Field, Ident, Ident, FieldAttribute)> = - BTreeMap::new(); - - for (index, field) in variant.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - enable_rank: true, - rank: isize::MIN + index as isize, - } - .build_from_attributes(&field.attrs, traits)?; - - let field_name_var_self = format_ident!("_{}", index); - - if field_attribute.ignore { - pattern_token_stream.extend(quote!(_,)); - pattern2_token_stream.extend(quote!(_,)); - - continue; - } - - let field_name_var_other = format_ident!("_{}", field_name_var_self); - - pattern_token_stream.extend(quote!(#field_name_var_self,)); - pattern2_token_stream.extend(quote!(#field_name_var_other,)); - - let rank = field_attribute.rank; - - if fields.contains_key(&rank) { - return Err(super::panic::reuse_a_rank( - field_attribute.rank_span.unwrap_or_else(|| field.span()), - rank, - )); - } - - fields.insert( - rank, - (field, field_name_var_self, field_name_var_other, field_attribute), - ); - } - - for (field, field_name, field_name2, field_attribute) in fields.values() { - let partial_cmp = - field_attribute.method.as_ref().unwrap_or_else(|| { - partial_ord_types.push(&field.ty); - - &built_in_partial_cmp - }); - - block_token_stream.extend(quote! { - match #partial_cmp(#field_name, #field_name2) { - Some(::core::cmp::Ordering::Equal) => (), - Some(::core::cmp::Ordering::Greater) => return Some(::core::cmp::Ordering::Greater), - Some(::core::cmp::Ordering::Less) => return Some(::core::cmp::Ordering::Less), - None => return None, - } - }); - } - - arms_token_stream.extend(quote! { - Self::#variant_ident ( #pattern_token_stream ) => { - if let Self::#variant_ident ( #pattern2_token_stream ) = other { - #block_token_stream - } - } - }); - }, - } - } - } - - if arms_token_stream.is_empty() { - partial_cmp_token_stream.extend(quote!(Some(::core::cmp::Ordering::Equal))); - } else { - let discriminant_cmp = quote! { - unsafe { - ::core::cmp::Ord::cmp(&*<*const _>::from(self).cast::<#discriminant_type>(), &*<*const _>::from(other).cast::<#discriminant_type>()) - } - }; - - partial_cmp_token_stream.extend(if all_unit { - quote! { - match #discriminant_cmp { - ::core::cmp::Ordering::Equal => Some(::core::cmp::Ordering::Equal), - ::core::cmp::Ordering::Greater => Some(::core::cmp::Ordering::Greater), - ::core::cmp::Ordering::Less => Some(::core::cmp::Ordering::Less), - } - } - } else { - quote! { - match #discriminant_cmp { - ::core::cmp::Ordering::Equal => { - match self { - #arms_token_stream - } - - Some(::core::cmp::Ordering::Equal) - }, - ::core::cmp::Ordering::Greater => Some(::core::cmp::Ordering::Greater), - ::core::cmp::Ordering::Less => Some(::core::cmp::Ordering::Less), - } - } - }); - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::PartialOrd)).unwrap(), - &partial_ord_types, - &[quote! {::core::cmp::PartialEq}], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialOrd for #ident #ty_generics #where_clause { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> { - #partial_cmp_token_stream - } - } - }); - - Ok(()) - } -} diff --git a/vendor/educe/src/trait_handlers/partial_ord/partial_ord_struct.rs b/vendor/educe/src/trait_handlers/partial_ord/partial_ord_struct.rs deleted file mode 100644 index 7b666447..00000000 --- a/vendor/educe/src/trait_handlers/partial_ord/partial_ord_struct.rs +++ /dev/null @@ -1,113 +0,0 @@ -use std::collections::BTreeMap; - -use quote::quote; -use syn::{spanned::Spanned, Data, DeriveInput, Field, Meta, Path, Type}; - -use super::{ - models::{FieldAttribute, FieldAttributeBuilder, TypeAttributeBuilder}, - TraitHandler, -}; -use crate::{common::ident_index::IdentOrIndex, Trait}; - -pub(crate) struct PartialOrdStructHandler; - -impl TraitHandler for PartialOrdStructHandler { - #[inline] - fn trait_meta_handler( - ast: &DeriveInput, - token_stream: &mut proc_macro2::TokenStream, - traits: &[Trait], - meta: &Meta, - ) -> syn::Result<()> { - let type_attribute = TypeAttributeBuilder { - enable_flag: true, enable_bound: true - } - .build_from_partial_ord_meta(meta)?; - - let mut partial_ord_types: Vec<&Type> = Vec::new(); - - let mut partial_cmp_token_stream = proc_macro2::TokenStream::new(); - - if let Data::Struct(data) = &ast.data { - let mut fields: BTreeMap<isize, (usize, &Field, FieldAttribute)> = BTreeMap::new(); - - for (index, field) in data.fields.iter().enumerate() { - let field_attribute = FieldAttributeBuilder { - enable_ignore: true, - enable_method: true, - enable_rank: true, - rank: isize::MIN + index as isize, - } - .build_from_attributes(&field.attrs, traits)?; - - if field_attribute.ignore { - continue; - } - - let rank = field_attribute.rank; - - if fields.contains_key(&rank) { - return Err(super::panic::reuse_a_rank( - field_attribute.rank_span.unwrap_or_else(|| field.span()), - rank, - )); - } - - fields.insert(rank, (index, field, field_attribute)); - } - - let built_in_partial_cmp: Path = - syn::parse2(quote!(::core::cmp::PartialOrd::partial_cmp)).unwrap(); - - for (index, field, field_attribute) in fields.values() { - let field_name = IdentOrIndex::from_ident_with_index(field.ident.as_ref(), *index); - - let partial_cmp = field_attribute.method.as_ref().unwrap_or_else(|| { - partial_ord_types.push(&field.ty); - - &built_in_partial_cmp - }); - - partial_cmp_token_stream.extend(quote! { - match #partial_cmp(&self.#field_name, &other.#field_name) { - Some(::core::cmp::Ordering::Equal) => (), - Some(::core::cmp::Ordering::Greater) => return Some(::core::cmp::Ordering::Greater), - Some(::core::cmp::Ordering::Less) => return Some(::core::cmp::Ordering::Less), - None => return None, - } - }); - } - } - - let ident = &ast.ident; - - let bound = type_attribute.bound.into_where_predicates_by_generic_parameters_check_types( - &ast.generics.params, - &syn::parse2(quote!(::core::cmp::PartialOrd)).unwrap(), - &partial_ord_types, - &[quote! {::core::cmp::PartialEq}], - ); - - let mut generics = ast.generics.clone(); - let where_clause = generics.make_where_clause(); - - for where_predicate in bound { - where_clause.predicates.push(where_predicate); - } - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - token_stream.extend(quote! { - impl #impl_generics ::core::cmp::PartialOrd for #ident #ty_generics #where_clause { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> { - #partial_cmp_token_stream - - Some(::core::cmp::Ordering::Equal) - } - } - }); - - Ok(()) - } -} |