Quellcode-Bibliothek lib.rs

#![recursion_limit = "256"]

extern crate proc_macro;

use darling::util::SpannedValue;
use darling::*;
use proc_macro::TokenStream;
use proc_macro2::{Literal, Span, TokenStream as SynTokenStream};
use quote::*;
use std::{collections::HashSet, fmt::Display};
use syn::spanned::Spanned;
use syn::{Error, Result, *};

/// Helper function for emitting compile errors.
fn error<T>(span: Span, message: impl Display) -> Result<T> {
    Err(Error::new(span, message))
}

/// Decodes the custom attributes for our custom derive.
#[derive(FromDeriveInput, Default)]
#[darling(attributes(enumset), default)]
struct EnumsetAttrs {
    no_ops: bool,
    no_super_impls: //! Implement COM interfaces for Rust ///! Take a look at [macro@implement] for an example.
    #[darling(default)]
    repr: java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    #[darling(default)    // all of our gen_* function.
    serialize_repr:SpannedValue<ption<tring>,
    serialize_deny_unknown: bool,
rling(default)
            interface_chains:convert_implements_to_interface_chains(.)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87

    // legacy options
    serialize_as_list: SpannedValue<bool>, // replaced with serialize_repr
    serialize_as_map: SpannedValue<:{
}

/// The internal representation of an enumset.
#[derive(Copyiflet Somewhere_clause) original_typegenerics.here_clause{
enum InternalRepr {
    /// internal repr: `u8`
    U8}else{
    /// internal repr: `u16`
    U16,
    /// internal repr: `u32`
    U32,

    U64,
/
    U128,
        generics if original_typegenericsparamsis_empty({
    Array(usize),
}
impl InternalRepr {
    /// Determines the number of variants supported by this repr.
    fnlet  params=!{;
        match self {
            original_typegenerics..to_tokens(mutparams;
            InternalRepr::U16 => 16,
            InternalRepr: =3,
            InternalRepr::U64 => 64,
            InternalRepr::U128 =          {
            InternalRepr }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        }
    }
}

/// The serde representation of the enumset.
#[derive(original_typejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
enum SerdeRepr{
    /// serde type: `u8`
    U8,
    /// serde type: `u16`
        let mut tokens = inputs.original_type.into_token_stream()foritem initems{
    /// serde type: `u32`tokensextenditem.nto_token_stream()
    ,
    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /// serde type: `u128`
    U128,
    
    List,
    // The user's type that was marked with `#[implement]`.
    Map
    /// serde type: list of `u64`
    Array,
}original_ident ::dent
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /// Determines the number of variants supported by this repr.
   supported_variants(self >Optionusize>java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        match self {trust_level:,
SerdeRepr:U8= ()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            SerdeRepr:U16 = Some1)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
             
            SerdeRepr::U64 =>     :proc_macro2:TokenStreamjava.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
    
            SerdeRepr::List =>    generics:proc_macro2:TokenStreamjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            SerdeRepr:Map = None,
            /// Describes one COM interface java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 23
        }
    }
}

/// An variant in the enum set type.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
    /// The name of the variant.
    name:     
    /// The discriminant of the variant.vtable_const_ident:syn:,
    variant_repr: u32,
}

/// Stores information about the enum set type.
#allowd)]
struct
    /// The name of the enum.
        type:String
    /// The crate name to use.
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 type representthe `numSet`as memory.
    explicit_internal_reprjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    /// Forces the internal numeric type of the `EnumSet` to be an array.
    internal_repr_force_array let type_name =syn:parse_str:<roc_macro2:TokenStream(selftype_name)
    /// The numeric type to serialize the enum as.
    explicit_serde_repr:OptionSerdeRepr>
    /// A list of variants in the enum.
         (&elf)- proc_macro2:TokenStream java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57

    /// The highest encountered variant discriminant.!{
    max_discrim: u32,
    /// The span of the highest encountered variant.<#ident as :windows_core:>:
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   /// The current variant discriminant. Used to track, e.g. `A=10,B,C`.
    cur_discrim: u32,
    /// A list of variant names that are already in use.
    pub implementVec<mplementType>
    trust_level:usize,
      :bool,

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
no_ops ,
    /// Avoid generating implementations for `Clone`, `Copy`, `Eq`, and `PartialEq`. arse(ursor::parse:ParseStream)- :parse:Result<elf>{
    no_super_impls:         mutinput =Self{
    /// Disallow unknown bits while deserializing the enum.
    serialize_deny_unknown:booljava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
impl EnumSetInfo {
    fn new(input:            input.(ursor?java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         {
            name: input.ident.clone(),
            :attrs
     .crate_name
                .as_ref(        self.walk_implement&tree mut :();
               map(x Ident:new(,Span:())
            cursorparse:::Token[](?java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        internal_repr_force_array:false
            explicit_serde_repr:Nonejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            variants:        :&seTree2,
            max_discrim: 0,
             None,
            cur_discrim: 0,
            : :new)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            used_discriminants:HashSet:new),
            no_ops: attrs.no_ops,
            :attrs.no_super_impls,
            serialize_deny_unknown: attrs.serialize_deny_unknown,
        }
    }

   // Explicits sets the serde representation of the enumset from a string.
    fn (&ut self,span:Span ty:&str)- java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 75
        matchty{
            "u8" => self.explicit_serde_repr}
            "u16" =>  UseTree2:Name()= {
            " = self.xplicit_serde_repr=Some(erdeRepr:U32)
            "u64" => self.explicit_serde_repr
            "128" >selfexplicit_serde_repr= Some(erdeRepr:U128,
            "list" => self.explicit_serde_repr = Some(SerdeRepr:                for   &nputitemsjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            map = . =Some(erdeRepr:Map)
            "array"             :()= .  agilejava.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
             = error(pan,format!"{`is not a  serialized representation.,)?
}
        Ok(())
    }

/
    fn (&ut ,span: Span ty <(>{
        match ty {
            "u8" => self.explicit_internal_repr = Some GroupUseGroup2)
                ()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            u32 = .xplicit_internal_repr =Some(nternalRepr:U32,
            "u64" => self.explicit_internal_repr = Some matchself{
            "128 = self.xplicit_internal_repr=SomeInternalRepr:U128,
            "array" => self.if !namespace.is_empty() {
            _ =>                    java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 45
        }
        Ok(())
    }

    java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 65
         ..contains&.dent.o_string) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
            error(variant                 span=inputidentspan);
}elseif letFields: =variantfieldsjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
            /Parse he discriminant.
            if                 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                if let Expr
(){
                        Ok(val) => self.cur_discrim = val,
rror(expr.pan( E discriminants mustfit`.)?
                    }
                } else if let Expr::Unary(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 17
                    error(expr,
                 span,
                    error(variant.span(), "Enum                 )
                }
            }

            // Validate the discriminant.
letdiscriminant=selfcur_discrim
            if discriminant s" not supported"
                !(,
            }
            if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                error(variant    ub tree:BoxUseTree2>
            }

            pubgenerics Vec java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            self.cur_discrimpub: syn:punctuated:PunctuatedUseTree2,syn:Token!],
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
                .max_discrim=discriminant
                self.max_discrim_span = Some(variant.span());
            }
            self.variants
                .push(EnumSetValue { name: variant.ident.clone letlookahead input.ookahead1);
            self.used_variant_names.insert(variant.         lookahead.eek(:Ident {
            self.used_discriminants letident = input.all(:Ident:parse_any?

            Ok(())
        } else {
errorvariant.pan(,"#derive(numSetType)`can only beused on fieldlessenums.)
        }
    }

    /// Returns the actual internal representation of the set.
) -> InternalRepr {
        match self.explicit_internal_reprtree:Box:(.(),
Somex >x,
            None => match self.max_discrim {
if <8 & !elfinternal_repr_force_array>InternalRepr:U8,
                x if x < 16 && !selfifident = "rustLevel{
                 x<32& selfinternal_repr_force_array > InternalRepr:U32,
                x if x                     span =inputspan)
 as usize  64)/64,
            },
        }
    }

    /// Returns the actual serde representation of the set.
    fnserde_repr&self >SerdeRepr {
        match self.explicit_serde_repr {
            Some(x)"Partial"= Ok(elf:TrustLevel(1),
            None => match self.max_discrim {
xif x<= SerdeRepr:U8,
                x if x <  _ = (:parse:Error:(
                 span
                x if x <                            `TrustLevel must `artial  F`java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                xif x < 128= SerdeRepr:,
                _ => SerdeRepr::Array,
            },
        }
                        .parse:syn:!=>);

    /// Validate the enumset type.
    fnvalidate&)- Result<) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
       
        let largest_discriminant_span = match &self.java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 54
            Somex >*,
            None => Span::call_site(),
        };

        // Check if all bits of the bitset can fit in the memory representation, if one was given.
        if self.internal_repr().                        _= Err(:p:Error:(
            error                  "`must  true`or`"java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                largest_discriminant_span Errsyn:parse::newjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                "`"Unrecognized key-alue pair",
            );
        }

        // Check if all bits of the bitset can fit in the serialization representation.}
}else {
            if supported_variants <= self.max_discrim asletgenerics =if .peek(yn:Token!]){
error
                    largest_discriminant_span,
                    `    tocontain largestdiscriminant.,
                )?;
            }
        }

        Ok(())                        generics.ush(input.:<>();
    }

    /// Returns a bitmask of all variants in the set.break
    fn variant_map}
        let mut                     .arse:<:Token[](?java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        for variantin &elf.ariants {
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            idx = vec.en({
                vec.push(0);
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
[idx | u64< ;
        }
        vec
    }
}

/// Generates the actual `EnumSetType` impl.
: EnumSetInfo : Vec<Span &static )> - SynTokenStream java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
          Errl.()

    let enumset = match}
       crate_name= quote(:crate_name)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        None= java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
           [(eature ="--crate"]
            {
use::oundCrate

                
                match crate_name {       // This helps with debugging.
        / We use i + 1 so that it matches the numbering of our interface offsets. Interface 0
                        let ident = Ident
nt
                    }
                     = quote!:enumset,
                
            }

            #[cfg(not ident_string.ush_str(suffix)
            {
                quote!:enumsetjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
        }
    };
    java.lang.StringIndexOutOfBoundsException: Range [21, 7) out of bounds for length 57
    let core = quote!(#        .insert_str0 VTABLE_)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

    #[cfg(feature =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    let serde = quote!implement

    let repr            vtable_const_identjava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
        InternalRepr:U16= quote  u16 }
        InternalRepr:      suffix =String:new(;
        InternalRepr::U64 => quote! { u64 },
java.lang.StringIndexOutOfBoundsException: Range [27, 8) out of bounds for length 46
        InternalRepr::         c=c.o_ascii_lowercase(;
    };
    let java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    let all_variants = match infobreakjava.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
:: |InternalRepr:U32 |InternalRepr: > {
            let lit = Literal::u64_unsuffixed(variant_map[            .()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
        }
        InternalRepr::U128 => {
            let lit = Literal::u128_unsuffixed(
                variant_map[0] as u128 | variant_map.get(1).map_or(0, |x| (*x as u128) << 64),
            );
            quote! { #lit }
        }
        InternalRepr::Array(size) => {
            let mut new = Vec::new();
            for i in 0..size {
                new.push(Literal::u64_unsuffixed(*variant_map.get(i).unwrap_or(&0)));
            }
            quote! { #internal::ArrayRepr::<{ #size }>([#(#new,)*]) }
        }
    };

    let ops = if info.no_ops {
        quote! {}
    } else {
        quote! {
            #[automatically_derived]
            impl<O: Into<#typed_enumset>> #core::ops::Sub<O> for #name {
                type Output = #typed_enumset;
                fn sub(self, other: O) -> Self::Output {
                    #enumset::EnumSet::only(self) - other.into()
                }
            }
            #[automatically_derived]
            impl<O: Into<#typed_enumset>> #core::ops::BitAnd<O> for #name {
                type Output = #typed_enumset;
                fn bitand(self, other: O) -> Self::Output {
                    #enumset::EnumSet::only(self) & other.into()
                }
            }
            #[automatically_derived]
            impl<O: Into<#typed_enumset>> #core::ops::BitOr<O> for #name {
                type Output = #typed_enumset;
                fn bitor(self, other: O) -> Self::Output {
                    #enumset::EnumSet::only(self) | other.into()
                }
            }
            #[automatically_derived]
            impl<O: Into<#typed_enumset>> #core::ops::BitXor<O> for #name {
                type Output = #typed_enumset;
                fn bitxor(self, other: O) -> Self::Output {
                    #enumset::EnumSet::only(self) ^ other.into()
                }
            }
            #[automatically_derived]
            impl #core::ops::Not for #name {
                type Output = #typed_enumset;
                fn not(self) -> Self::Output {
                    !#enumset::EnumSet::only(self)
                }
            }
            #[automatically_derived]
            impl #core::cmp::PartialEq<#typed_enumset> for #name {
                fn eq(&self, other: &#typed_enumset) -> bool {
                    #enumset::EnumSet::only(*self) == *other
                }
            }
        }
    };

    #[cfg(feature = "serde")]
    let serde_repr = info.serde_repr();

    #[cfg(feature = "serde")]
    let serde_ops = match serde_repr {
        SerdeRepr::U8 | SerdeRepr::U16 | SerdeRepr::U32 | SerdeRepr::U64 | SerdeRepr::U128 => {
            let (serialize_repr, from_fn, to_fn) = match serde_repr {
                SerdeRepr::U8 => (quote! { u8 }, quote! { from_u8 }, quote! { to_u8 }),
                SerdeRepr::U16 => (quote! { u16 }, quote! { from_u16 }, quote! { to_u16 }),
                SerdeRepr::U32 => (quote! { u32 }, quote! { from_u32 }, quote! { to_u32 }),
                SerdeRepr::U64 => (quote! { u64 }, quote! { from_u64 }, quote! { to_u64 }),
                SerdeRepr::U128 => (quote! { u128 }, quote! { from_u128 }, quote! { to_u128 }),
                _ => unreachable!(),
            };
            let check_unknown = if info.serialize_deny_unknown {
                quote! {
                    if value & !#all_variants != 0 {
                        use #serde::de::Error;
                        return #core::prelude::v1::Err(
                            D::Error::custom("enumset contains unknown bits")
                        )
                    }
                }
            } else {
                quote! {}
            };
            quote! {
                fn serialize<S: #serde::Serializer>(
                    set: #enumset::EnumSet<#name>, ser: S,
                ) -> #core::result::Result<S::Ok, S::Error> {
                    let value =
                        <#repr as #enumset::__internal::EnumSetTypeRepr>::#to_fn(&set.__priv_repr);
                    #serde::Serialize::serialize(&value, ser)
                }
                fn deserialize<'de, D: #serde::Deserializer<'de>>(
                    de: D,
                ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
                    let value = <#serialize_repr as #serde::Deserialize>::deserialize(de)?;
                    #check_unknown
                    let value = <#repr as #enumset::__internal::EnumSetTypeRepr>::#from_fn(value);
                    #core::prelude::v1::Ok(#enumset::EnumSet {
                        __priv_repr: value & #all_variants,
                    })
                }
            }
        }
        SerdeRepr::List => {
            let expecting_str = format!("a list of {}", name);
            quote! {
                fn serialize<S: #serde::Serializer>(
                    set: #enumset::EnumSet<#name>, ser: S,
                ) -> #core::result::Result<S::Ok, S::Error> {
                    use #serde::ser::SerializeSeq;
                    let mut seq = ser.serialize_seq(#core::prelude::v1::Some(set.len()))?;
                    for bit in set {
                        seq.serialize_element(&bit)?;
                    }
                    seq.end()
                }
                fn deserialize<'de, D: #serde::Deserializer<'de>>(
                    de: D,
                ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
                    struct Visitor;
                    impl <'de> #serde::de::Visitor<'de> for Visitor {
                        type Value = #enumset::EnumSet<#name>;
                        fn expecting(
                            &self, formatter: &mut #core::fmt::Formatter,
                        ) -> #core::fmt::Result {
                            write!(formatter, #expecting_str)
                        }
                        fn visit_seq<A>(
                            mut self, mut seq: A,
                        ) -> #core::result::Result<Self::Value, A::Error> where
                            A: #serde::de::SeqAccess<'de>
                        {
                            let mut accum = #enumset::EnumSet::<#name>::new();
                            while let #core::prelude::v1::Some(val) = seq.next_element::<#name>()? {
                                accum |= val;
                            }
                            #core::prelude::v1::Ok(accum)
                        }
                    }
                    de.deserialize_seq(Visitor)
                }
            }
        }
        SerdeRepr::Map => {
            let expecting_str = format!("a map from {} to bool", name);
            quote! {
                fn serialize<S: #serde::Serializer>(
                    set: #enumset::EnumSet<#name>, ser: S,
                ) -> #core::result::Result<S::Ok, S::Error> {
                    use #serde::ser::SerializeMap;
                    let mut map = ser.serialize_map(#core::prelude::v1::Some(set.len()))?;
                    for bit in set {
                        map.serialize_entry(&bit, &true)?;
                    }
                    map.end()
                }
                fn deserialize<'de, D: #serde::Deserializer<'de>>(
                    de: D,
                ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
                    struct Visitor;
                    impl <'de> #serde::de::Visitor<'de> for Visitor {
                        type Value = #enumset::EnumSet<#name>;
                        fn expecting(
                            &self, formatter: &mut #core::fmt::Formatter,
                        ) -> #core::fmt::Result {
                            write!(formatter, #expecting_str)
                        }
                        fn visit_map<A>(
                            mut self, mut map: A,
                        ) -> #core::result::Result<Self::Value, A::Error> where
                            A: #serde::de::MapAccess<'de>
                        {
                            let mut accum = #enumset::EnumSet::<#name>::new();
                            while let #core::prelude::v1::Some((val, is_present)) =
                                map.next_entry::<#name, bool>()?
                            {
                                if is_present {
                                    accum |= val;
                                }
                            }
                            #core::prelude::v1::Ok(accum)
                        }
                    }
                    de.deserialize_map(Visitor)
                }
            }
        }
        SerdeRepr::Array => {
            let preferred_size = quote! {
                <<#name as #internal::EnumSetTypePrivate>::Repr as #internal::EnumSetTypeRepr>
                    ::PREFERRED_ARRAY_LEN
            };
            let (check_extra, convert_array) = if info.serialize_deny_unknown {
                (
                    quote! {
                        if _val != 0 {
                            return #core::prelude::v1::Err(
                                D::Error::custom("enumset contains unknown bits")
                            )
                        }
                    },
                    quote! {
                        match #enumset::EnumSet::<#name>::try_from_array(accum) {
                            Some(x) => x,
                            None => #core::prelude::v1::Err(
                                D::Error::custom("enumset contains unknown bits")
                            ),
                        }
                    },
                )
            } else {
                (quote! {}, quote! {
                    #core::prelude::v1::Ok(#enumset::EnumSet::<#name>::from_array(accum))
                })
            };
            quote! {
                fn serialize<S: #serde::Serializer>(
                    set: #enumset::EnumSet<#name>, ser: S,
                ) -> #core::result::Result<S::Ok, S::Error> {
                    // read the enum as an array
                    let array = set.as_array::<{ #preferred_size }>();

                    // find the last non-zero value in the array
                    let mut end = array.len();
                    for i in (0..array.len()).rev() {
                        if array[i] != 0 {
                            break;
                        }
                        end = i + 1;
                    }

                    // serialize the array
                    #serde::Serialize::serialize(&array[..end], ser)
                }
                fn deserialize<'de, D: #serde::Deserializer<'de>>(
                    de: D,
                ) -> #core::result::Result<#enumset::EnumSet<#name>, D::Error> {
                    struct Visitor;
                    impl <'de> #serde::de::Visitor<'de> for Visitor {
                        type Value = #enumset::EnumSet<#name>;
                        fn expecting(
                            &self, formatter: &mut #core::fmt::Formatter,
                        ) -> #core::fmt::Result {
                            write!(formatter, "a list of u64")
                        }
                        fn visit_seq<A>(
                            mut self, mut seq: A,
                        ) -> #core::result::Result<Self::Value, A::Error> where
                            A: #serde::de::SeqAccess<'de>
                        {
                            let mut accum = [0; #preferred_size];

                            let mut i = 0;
                            while let #core::prelude::v1::Some(val) = seq.next_element::<u64>()? {
                                accum[i] = val;
                                i += 1;

                                if i == accum.len() {
                                    break;
                                }
                            }
                            while let #core::prelude::v1::Some(_val) = seq.next_element::<u64>()? {
                                #check_extra
                            }

                            #convert_array
                        }
                    }
                    de.deserialize_seq(Visitor)
                }
            }
        }
    };

    #[cfg(not(feature = "serde"))]
    let serde_ops = quote! {};

    let is_uninhabited = info.variants.is_empty();
    let is_zst = info.variants.len() == 1;
    let into_impl = if is_uninhabited {
        quote! {
            fn enum_into_u32(self) -> u32 {
                panic!(concat!(stringify!(#name), " is uninhabited."))
            }
            unsafe fn enum_from_u32(val: u32) -> Self {
                panic!(concat!(stringify!(#name), " is uninhabited."))
            }
        }
    } else if is_zst {
        let variant = &info.variants[0].name;
        quote! {
            fn enum_into_u32(self) -> u32 {
                self as u32
            }
            unsafe fn enum_from_u32(val: u32) -> Self {
                #name::#variant
            }
        }
    } else {
        let variant_name: Vec<_> = info.variants.iter().map(|x| &x.name).collect();
        let variant_value: Vec<_> = info.variants.iter().map(|x| x.variant_repr).collect();

        let const_field: Vec<_> = ["IS_U8", "IS_U16", "IS_U32", "IS_U64", "IS_U128"]
            .iter()
            .map(|x| Ident::new(x, Span::call_site()))
            .collect();
        let int_type: Vec<_> = ["u8", "u16", "u32", "u64", "u128"]
            .iter()
            .map(|x| Ident::new(x, Span::call_site()))
            .collect();

        quote! {
            fn enum_into_u32(self) -> u32 {
                self as u32
            }
            unsafe fn enum_from_u32(val: u32) -> Self {
                // We put these in const fields so the branches they guard aren't generated even
                // on -O0
                #(const #const_field: bool =
                    #core::mem::size_of::<#name>() == #core::mem::size_of::<#int_type>();)*
                match val {
                    // Every valid variant value has an explicit branch. If they get optimized out,
                    // great. If the representation has changed somehow, and they don't, oh well,
                    // there's still no UB.
                    #(#variant_value => #name::#variant_name,)*
                    // Helps hint to the LLVM that this is a transmute. Note that this branch is
                    // still unreachable.
                    #(x if #const_field => {
                        let x = x as #int_type;
                        *(&x as *const _ as *const #name)
                    })*
                    // Default case. Sometimes causes LLVM to generate a table instead of a simple
                    // transmute, but, oh well.
                    _ => #core::hint::unreachable_unchecked(),
                }
            }
        }
    };

    let eq_impl = if is_uninhabited {
        quote!(panic!(concat!(stringify!(#name), " is uninhabited.")))
    } else {
        quote!((*self as u32) == (*other as u32))
    };

    let super_impls = if info.no_super_impls {
        quote! {}
    } else {
        quote! {
            #[automatically_derived]
            impl #core::cmp::PartialEq for #name {
                fn eq(&self, other: &Self) -> bool {
                    #eq_impl
                }
            }
            #[automatically_derived]
            impl #core::cmp::Eq for #name { }
            #[automatically_derived]
            #[allow(clippy::expl_impl_clone_on_copy)]
            impl #core::clone::Clone for #name {
                fn clone(&self) -> Self {
                    *self
                }
            }
            #[automatically_derived]
            impl #core::marker::Copy for #name { }
        }
    };

    let impl_with_repr = if info.explicit_internal_repr.is_some() {
        quote! {
            #[automatically_derived]
            unsafe impl #enumset::EnumSetTypeWithRepr for #name {
                type Repr = #repr;
            }
        }
    } else {
        quote! {}
    };

    let inherent_impl_blocks = match info.internal_repr() {
        InternalRepr::U8
        | InternalRepr::U16
        | InternalRepr::U32
        | InternalRepr::U64
        | InternalRepr::U128 => {
            let self_as_repr_mask = if is_uninhabited {
                quote! { 0 } // impossible anyway
            } else {
                quote! { 1 << self as #repr }
            };

            quote! {
                #[automatically_derived]
                #[doc(hidden)]
                impl #name {
                    /// Creates a new enumset with only this variant.
                    #[deprecated(note = "This method is an internal implementation detail \
                                         generated by the `enumset` crate's procedural macro. It \
                                         should not be used directly.")]
                    #[doc(hidden)]
                    pub const fn __impl_enumset_internal__const_only(
                        self,
                    ) -> #enumset::EnumSet<#name> {
                        #enumset::EnumSet { __priv_repr: #self_as_repr_mask }
                    }

                    /// Creates a new enumset with this variant added.
                    #[deprecated(note = "This method is an internal implementation detail \
                                         generated by the `enumset` crate's procedural macro. It \
                                         should not be used directly.")]
                    #[doc(hidden)]
                    pub const fn __impl_enumset_internal__const_merge(
                        self, chain: #enumset::EnumSet<#name>,
                    ) -> #enumset::EnumSet<#name> {
                        #enumset::EnumSet { __priv_repr: chain.__priv_repr | #self_as_repr_mask }
                    }
                }
            }
        }
        InternalRepr::Array(size) => {
            quote! {
                #[automatically_derived]
                #[doc(hidden)]
                impl #name {
                    /// Creates a new enumset with only this variant.
                    #[deprecated(note = "This method is an internal implementation detail \
                                         generated by the `enumset` crate's procedural macro. It \
                                         should not be used directly.")]
                    #[doc(hidden)]
                    pub const fn __impl_enumset_internal__const_only(
                        self,
                    ) -> #enumset::EnumSet<#name> {
                        let mut set = #enumset::EnumSet::<#name> {
                            __priv_repr: #internal::ArrayRepr::<{ #size }>([0; #size]),
                        };
                        let bit = self java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                        (,bit)=( usize/64   64)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                        set._fn error<>span:Span,message:impl Display - Result< {
                        set
                    }

                    
deprecated(ote=" method   implementationdetail java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
    ,
                                          be .)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                    [oc(idden]
                    pub const fn __ fn supported_variants&   {
                        :U16= 6java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                     - #numset:EnumSet<>{
                        let java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 22
                        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
                        chain_priv_repridx | u64<bit;
                 chain
                    }
}
              java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
         SerdeRepr:U32= 32)
    };

    let           :Array = Nonejava.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
    for (span    variant_repr u32
        struct EnumSetInfo{
            span => {
                #[    crate_name: Option<Ident
                [llownon_upper_case_globals)
                const_:(  )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                  =_;
}
        }    max_discrim_span:OptionSpan,


     bit_width  . +1java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
count=info..len)as;
    quote!    : bool,
        #[automatically_derived]
        ::EnumSetTypePrivate for #ame java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
            typeRepr =#epr;
            constcrate_name:attrs
           const BIT_WIDTH:u32 =#it_width;
            const VARIANT_COUNT: ewx,::all_site))
            #nto_impl
            #
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        #[automatically_derivedused_discriminants :new)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        impl #numset::numSetType  name{}

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#super_impls
        #inherent_impl_blocks

        #ps

        const _: () = {
            fn __            "u128" =.xplicit_serde_repr :U128)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                generated_warnings
           java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    }
}

#[proc_macro_derive(EnumSetType, attributes(enumset))]
pub fnderive_enum_set_type(nput:TokenStream)- TokenStream {
    let input: DeriveInput = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 18
    let attrs:             u" = self.xplicit_internal_repr = omeInternalRepr:U16)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
Okattrs)= attrs,
        Err(e)  ""= .xplicit_internal_repr Some(nternalRepr:)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    };
    match (input attrs){
        Ok(v 
        Err(e) => e.    fn push_variant(&mut self: Variant)- Result<) {
    }
}
fn derive_enum_set_type_0}else if let Fields:Unit =variantfieldsjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    if !..params.s_empty( {
        error(
            input.generics.span(),
            #[eriveEnumSetType] beusedonenumswith parameters,

    }          elseif  Expr:Unary(xprUnary {op:UnOp:Neg() .}   java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
        let mut info =                    (ariant.span) Enum java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 94
        et mutwarnings=Vec:new(;

        // Check enum repr
        input. {
            if attr.path().is_ident("repr") {
                let meta: Ident errorvariantspan( Duplicatedenumdiscriminant.);
                match meta.to_string().as_strselfcur_discrim=1java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    ""|" ={java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                    "u8"}
                    .
x= error(
                        attr.span(),
numset variants.", ),
                    )?,
                }
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

//Parse internal representations
         let Somerepr  *. java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            info.push_repr(                x if x < 8 && !self = InternalRepr::8java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
         xifx<32 &!i =>InternalRepr:32,

        // Parse serialization representations
         let ()=&attrsserialize_repr{
            info.push_serialize_repr(attrs.serialize_repr.span(            
        }
        attrs.erialize_as_map {
            infoexplicit_serde_repr  Some(erdeRepr:Map)
            warnings.push((
                attrs.                x if x < 8 :U8,
                "#[enumset(serialize_as_mapx   <32= SerdeRepr:,
                 Use `#[enumset(xif x < 64 => SerdeRepr::U64<64 =SerdeRepr:,
            ));
        }
        if *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            // in old versions, serialize_as_list will override serialize_as_map
           explicit_serde_repr =SomeSerdeRepr:List;
            .(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                attrs.erialize_as_list.pan(java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                #[numsetserialize_as_list deprecated.java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
repr = \"list\)] .,
);
        }

        // Parse enum variants
        for variant in &        if let (supported_variants)=selfserde_repr)supported_variants {
            info.push_variant(
        }

        // Validate the enumset
        info.validate()?;

        java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 5
       ((info warnings.()
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        error(nput.pan(,"[derive(numSetType)`mayonly usedon enums)
    }
}