Skip to main content

rustc_attr_ir/
data_structures.rs

1use std::borrow::Cow;
2use std::fmt;
3use std::path::PathBuf;
4
5pub use ReprAttr::*;
6use rustc_abi::Align;
7pub use rustc_ast::attr::data_structures::*;
8pub use rustc_ast::attr::version::RustcVersion;
9use rustc_ast::expand::autodiff_attrs::{DiffActivity, DiffMode};
10use rustc_ast::expand::typetree::TypeTree;
11use rustc_ast::token::DocFragmentKind;
12use rustc_ast::{AttrStyle, Path, ast};
13use rustc_data_structures::fx::FxIndexMap;
14use rustc_error_messages::{DiagArgValue, IntoDiagArg};
15use rustc_macros::{
16    Decodable, Decodable_NoContext, Encodable, Encodable_NoContext, PrintAttribute, StableHash,
17};
18use rustc_span::def_id::DefId;
19use rustc_span::hygiene::Transparency;
20use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
21use rustc_structures::{CollapseMacroDebuginfo, CrateType, Limit, NativeLibKind, SanitizerSet};
22use thin_vec::ThinVec;
23
24pub use crate::canonical_symbols::{CanonicalSymbol, CanonicalSymbols};
25use crate::diagnostic::*;
26use crate::lang_items::LangItem;
27use crate::lint::LintCheck;
28use crate::pretty_printing::PrintAttribute;
29use crate::stability::{DefaultBodyStability, PartialConstStability, Stability};
30
31#[derive(#[automatically_derived]impl ::core::marker::Copy for EiiImplResolution { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for EiiImplResolution {
}
#[automatically_derived]impl ::core::clone::Clone for EiiImplResolution {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<DefId>;
        let _: ::core::clone::AssertParamIsClone<ErrorGuaranteed>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for EiiImplResolution {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Macro(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Macro",
                    &__self_0),
            Self::Known(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Known",
                    &__self_0),
            Self::Error(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Error",
                    &__self_0),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            EiiImplResolution {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    EiiImplResolution::Macro(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    EiiImplResolution::Known(ref __binding_0) =>
                        1u8.stable_hash(__hcx, __hasher),
                    EiiImplResolution::Error(ref __binding_0) =>
                        2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    EiiImplResolution::Macro(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    EiiImplResolution::Known(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    EiiImplResolution::Error(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for EiiImplResolution {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        EiiImplResolution::Macro(ref __binding_0) => { 0usize }
                        EiiImplResolution::Known(ref __binding_0) => { 1usize }
                        EiiImplResolution::Error(ref __binding_0) => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    EiiImplResolution::Macro(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    EiiImplResolution::Known(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    EiiImplResolution::Error(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for EiiImplResolution {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        EiiImplResolution::Macro(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => {
                        EiiImplResolution::Known(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    2usize => {
                        EiiImplResolution::Error(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `EiiImplResolution`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for EiiImplResolution {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Macro(f0) => {
                        __p.word("Macro");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Known(f0) => {
                        __p.word("Known");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Error(f0) => {
                        __p.word("Error");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute)]
32pub enum EiiImplResolution {
33    /// Usually, finding the extern item that an EII implementation implements means finding
34    /// the defid of the associated attribute macro, and looking at *its* attributes to find
35    /// what foreign item its associated with.
36    Macro(DefId),
37    /// Sometimes though, we already know statically and can skip some name resolution.
38    /// DefId of the extern item that the EII implementation implements.
39    Known(DefId),
40    /// For when resolution failed, but we want to continue compilation
41    Error(ErrorGuaranteed),
42}
43
44#[derive(#[automatically_derived]impl ::core::marker::Copy for EiiImpl { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for EiiImpl {
}
#[automatically_derived]impl ::core::clone::Clone for EiiImpl {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<EiiImplResolution>;
        let _: ::core::clone::AssertParamIsClone<Option<Span>>;
        let _: ::core::clone::AssertParamIsClone<Span>;
        let _: ::core::clone::AssertParamIsClone<bool>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for EiiImpl {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field5_finish(f,
            "EiiImpl resolution impl_unsafe_span span inner_span is_default",
            &self.resolution, &self.impl_unsafe_span, &self.span,
            &self.inner_span, &&self.is_default)
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for EiiImpl {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    EiiImpl {
                        resolution: ref __binding_0,
                        impl_unsafe_span: ref __binding_1,
                        span: ref __binding_2,
                        inner_span: ref __binding_3,
                        is_default: ref __binding_4 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                        { __binding_4.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for EiiImpl {
            fn encode(&self, __encoder: &mut __E) {
                let EiiImpl {
                        resolution: ref __binding_0,
                        impl_unsafe_span: ref __binding_1,
                        span: ref __binding_2,
                        inner_span: ref __binding_3,
                        is_default: ref __binding_4 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_4,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for EiiImpl {
            fn decode(__decoder: &mut __D) -> Self {
                EiiImpl {
                    resolution: ::rustc_serialize::Decodable::decode(__decoder),
                    impl_unsafe_span: ::rustc_serialize::Decodable::decode(__decoder),
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                    inner_span: ::rustc_serialize::Decodable::decode(__decoder),
                    is_default: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for EiiImpl {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self {
                        resolution, impl_unsafe_span, span, inner_span, is_default
                        } = self;
                __p.word("EiiImpl");
                if true && !resolution.should_render() &&
                                    !impl_unsafe_span.should_render() && !span.should_render()
                            && !inner_span.should_render() &&
                        !is_default.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if resolution.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("resolution");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                resolution.print_attribute(__p);
                if impl_unsafe_span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("impl_unsafe_span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                impl_unsafe_span.print_attribute(__p);
                if span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                span.print_attribute(__p);
                if inner_span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("inner_span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                inner_span.print_attribute(__p);
                if is_default.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("is_default");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                is_default.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
45pub struct EiiImpl {
46    pub resolution: EiiImplResolution,
47    pub impl_unsafe_span: Option<Span>,
48    pub span: Span,
49    pub inner_span: Span,
50    pub is_default: bool,
51}
52
53#[derive(#[automatically_derived]impl ::core::marker::Copy for EiiDecl { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for EiiDecl {
}
#[automatically_derived]impl ::core::clone::Clone for EiiDecl {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<DefId>;
        let _: ::core::clone::AssertParamIsClone<bool>;
        let _: ::core::clone::AssertParamIsClone<Ident>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for EiiDecl {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field3_finish(f,
            "EiiDecl foreign_item impl_unsafe name", &self.foreign_item,
            &self.impl_unsafe, &&self.name)
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for EiiDecl {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    EiiDecl {
                        foreign_item: ref __binding_0,
                        impl_unsafe: ref __binding_1,
                        name: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for EiiDecl {
            fn encode(&self, __encoder: &mut __E) {
                let EiiDecl {
                        foreign_item: ref __binding_0,
                        impl_unsafe: ref __binding_1,
                        name: ref __binding_2 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for EiiDecl {
            fn decode(__decoder: &mut __D) -> Self {
                EiiDecl {
                    foreign_item: ::rustc_serialize::Decodable::decode(__decoder),
                    impl_unsafe: ::rustc_serialize::Decodable::decode(__decoder),
                    name: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for EiiDecl {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { foreign_item, impl_unsafe, name } = self;
                __p.word("EiiDecl");
                if true && !foreign_item.should_render() &&
                            !impl_unsafe.should_render() && !name.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if foreign_item.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("foreign_item");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                foreign_item.print_attribute(__p);
                if impl_unsafe.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("impl_unsafe");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                impl_unsafe.print_attribute(__p);
                if name.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("name");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                name.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
54pub struct EiiDecl {
55    pub foreign_item: DefId,
56    /// whether or not it is unsafe to implement this EII
57    pub impl_unsafe: bool,
58    pub name: Ident,
59}
60
61#[derive(#[automatically_derived]impl ::core::marker::Copy for CguKind { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for CguKind {
}
#[automatically_derived]impl ::core::clone::Clone for CguKind {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for CguKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for CguKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for CguKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        CguKind::No => { 0usize }
                        CguKind::PreDashLto => { 1usize }
                        CguKind::PostDashLto => { 2usize }
                        CguKind::Any => { 3usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for CguKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { CguKind::No }
                    1usize => { CguKind::PreDashLto }
                    2usize => { CguKind::PostDashLto }
                    3usize => { CguKind::Any }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `CguKind`, expected 0..4, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for CguKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                CguKind::No => "No",
                CguKind::PreDashLto => "PreDashLto",
                CguKind::PostDashLto => "PostDashLto",
                CguKind::Any => "Any",
            })
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for CguKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    CguKind::No => 0u8.stable_hash(__hcx, __hasher),
                    CguKind::PreDashLto => 1u8.stable_hash(__hcx, __hasher),
                    CguKind::PostDashLto => 2u8.stable_hash(__hcx, __hasher),
                    CguKind::Any => 3u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    CguKind::No => {}
                    CguKind::PreDashLto => {}
                    CguKind::PostDashLto => {}
                    CguKind::Any => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for CguKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::No => { __p.word("No") }
                    Self::PreDashLto => { __p.word("PreDashLto") }
                    Self::PostDashLto => { __p.word("PostDashLto") }
                    Self::Any => { __p.word("Any") }
                }
            }
        }
    };PrintAttribute)]
62pub enum CguKind {
63    No,
64    PreDashLto,
65    PostDashLto,
66    Any,
67}
68
69#[derive(#[automatically_derived]impl ::core::marker::Copy for CguFields { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for CguFields {
}
#[automatically_derived]impl ::core::clone::Clone for CguFields {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<Symbol>;
        let _: ::core::clone::AssertParamIsClone<CguKind>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for CguFields
    {
}
#[automatically_derived]impl ::core::cmp::PartialEq for CguFields {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::PartitionReused { cfg: __self_0, module: __self_1 },
                    Self::PartitionReused { cfg: __arg1_0, module: __arg1_1 })
                    => __self_0 == __arg1_0 && __self_1 == __arg1_1,
                (Self::PartitionCodegened { cfg: __self_0, module: __self_1 },
                    Self::PartitionCodegened { cfg: __arg1_0, module: __arg1_1
                    }) => __self_0 == __arg1_0 && __self_1 == __arg1_1,
                (Self::ExpectedCguReuse {
                    cfg: __self_0, module: __self_1, kind: __self_2 },
                    Self::ExpectedCguReuse {
                    cfg: __arg1_0, module: __arg1_1, kind: __arg1_2 }) =>
                    __self_0 == __arg1_0 && __self_1 == __arg1_1 &&
                        __self_2 == __arg1_2,
                _ => unsafe { ::core::intrinsics::unreachable() }
            }
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for CguFields {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        CguFields::PartitionReused {
                            cfg: ref __binding_0, module: ref __binding_1 } => {
                            0usize
                        }
                        CguFields::PartitionCodegened {
                            cfg: ref __binding_0, module: ref __binding_1 } => {
                            1usize
                        }
                        CguFields::ExpectedCguReuse {
                            cfg: ref __binding_0,
                            module: ref __binding_1,
                            kind: ref __binding_2 } => {
                            2usize
                        }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    CguFields::PartitionReused {
                        cfg: ref __binding_0, module: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    CguFields::PartitionCodegened {
                        cfg: ref __binding_0, module: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    CguFields::ExpectedCguReuse {
                        cfg: ref __binding_0,
                        module: ref __binding_1,
                        kind: ref __binding_2 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for CguFields {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        CguFields::PartitionReused {
                            cfg: ::rustc_serialize::Decodable::decode(__decoder),
                            module: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    1usize => {
                        CguFields::PartitionCodegened {
                            cfg: ::rustc_serialize::Decodable::decode(__decoder),
                            module: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    2usize => {
                        CguFields::ExpectedCguReuse {
                            cfg: ::rustc_serialize::Decodable::decode(__decoder),
                            module: ::rustc_serialize::Decodable::decode(__decoder),
                            kind: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `CguFields`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for CguFields {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::PartitionReused { cfg: __self_0, module: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "PartitionReused cfg module", __self_0, &__self_1),
            Self::PartitionCodegened { cfg: __self_0, module: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "PartitionCodegened cfg module", __self_0, &__self_1),
            Self::ExpectedCguReuse {
                cfg: __self_0, module: __self_1, kind: __self_2 } =>
                ::core::fmt::Formatter::debug_struct_field3_finish(f,
                    "ExpectedCguReuse cfg module kind", __self_0, __self_1,
                    &__self_2),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for CguFields {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    CguFields::PartitionReused {
                        cfg: ref __binding_0, module: ref __binding_1 } =>
                        0u8.stable_hash(__hcx, __hasher),
                    CguFields::PartitionCodegened {
                        cfg: ref __binding_0, module: ref __binding_1 } =>
                        1u8.stable_hash(__hcx, __hasher),
                    CguFields::ExpectedCguReuse {
                        cfg: ref __binding_0,
                        module: ref __binding_1,
                        kind: ref __binding_2 } => 2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    CguFields::PartitionReused {
                        cfg: ref __binding_0, module: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    CguFields::PartitionCodegened {
                        cfg: ref __binding_0, module: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    CguFields::ExpectedCguReuse {
                        cfg: ref __binding_0,
                        module: ref __binding_1,
                        kind: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for CguFields {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::PartitionReused { cfg, module } => {
                        __p.word("PartitionReused");
                        if true && !cfg.should_render() && !module.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if cfg.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("cfg");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        cfg.print_attribute(__p);
                        if module.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("module");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        module.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::PartitionCodegened { cfg, module } => {
                        __p.word("PartitionCodegened");
                        if true && !cfg.should_render() && !module.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if cfg.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("cfg");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        cfg.print_attribute(__p);
                        if module.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("module");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        module.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::ExpectedCguReuse { cfg, module, kind } => {
                        __p.word("ExpectedCguReuse");
                        if true && !cfg.should_render() && !module.should_render()
                                && !kind.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if cfg.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("cfg");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        cfg.print_attribute(__p);
                        if module.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("module");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        module.print_attribute(__p);
                        if kind.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("kind");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        kind.print_attribute(__p);
                        __p.word("}");
                    }
                }
            }
        }
    };PrintAttribute)]
70pub enum CguFields {
71    PartitionReused { cfg: Symbol, module: Symbol },
72    PartitionCodegened { cfg: Symbol, module: Symbol },
73    ExpectedCguReuse { cfg: Symbol, module: Symbol, kind: CguKind },
74}
75
76#[derive(#[automatically_derived]impl ::core::marker::Copy for InlineAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for InlineAttr {
}
#[automatically_derived]impl ::core::clone::Clone for InlineAttr {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<Span>;
        let _: ::core::clone::AssertParamIsClone<Option<Symbol>>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    InlineAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for InlineAttr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Force { attr_span: __self_0, reason: __self_1 },
                    Self::Force { attr_span: __arg1_0, reason: __arg1_1 }) =>
                    __self_0 == __arg1_0 && __self_1 == __arg1_1,
                _ => true,
            }
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for InlineAttr {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        InlineAttr::None => { 0usize }
                        InlineAttr::Hint => { 1usize }
                        InlineAttr::Always => { 2usize }
                        InlineAttr::Never => { 3usize }
                        InlineAttr::Force {
                            attr_span: ref __binding_0, reason: ref __binding_1 } => {
                            4usize
                        }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    InlineAttr::None => {}
                    InlineAttr::Hint => {}
                    InlineAttr::Always => {}
                    InlineAttr::Never => {}
                    InlineAttr::Force {
                        attr_span: ref __binding_0, reason: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for InlineAttr {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { InlineAttr::None }
                    1usize => { InlineAttr::Hint }
                    2usize => { InlineAttr::Always }
                    3usize => { InlineAttr::Never }
                    4usize => {
                        InlineAttr::Force {
                            attr_span: ::rustc_serialize::Decodable::decode(__decoder),
                            reason: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `InlineAttr`, expected 0..5, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for InlineAttr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::None => ::core::fmt::Formatter::write_str(f, "None"),
            Self::Hint => ::core::fmt::Formatter::write_str(f, "Hint"),
            Self::Always => ::core::fmt::Formatter::write_str(f, "Always"),
            Self::Never => ::core::fmt::Formatter::write_str(f, "Never"),
            Self::Force { attr_span: __self_0, reason: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Force attr_span reason", __self_0, &__self_1),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for InlineAttr {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    InlineAttr::None => 0u8.stable_hash(__hcx, __hasher),
                    InlineAttr::Hint => 1u8.stable_hash(__hcx, __hasher),
                    InlineAttr::Always => 2u8.stable_hash(__hcx, __hasher),
                    InlineAttr::Never => 3u8.stable_hash(__hcx, __hasher),
                    InlineAttr::Force {
                        attr_span: ref __binding_0, reason: ref __binding_1 } =>
                        4u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    InlineAttr::None => {}
                    InlineAttr::Hint => {}
                    InlineAttr::Always => {}
                    InlineAttr::Never => {}
                    InlineAttr::Force {
                        attr_span: ref __binding_0, reason: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for InlineAttr {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::None => { __p.word("None") }
                    Self::Hint => { __p.word("Hint") }
                    Self::Always => { __p.word("Always") }
                    Self::Never => { __p.word("Never") }
                    Self::Force { attr_span, reason } => {
                        __p.word("Force");
                        if true && !attr_span.should_render() &&
                                !reason.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if attr_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_span.print_attribute(__p);
                        if reason.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("reason");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        reason.print_attribute(__p);
                        __p.word("}");
                    }
                }
            }
        }
    };PrintAttribute)]
77pub enum InlineAttr {
78    None,
79    Hint,
80    Always,
81    Never,
82    /// `#[rustc_force_inline]` forces inlining to happen in the MIR inliner - it reports an error
83    /// if the inlining cannot happen. It is limited to only free functions so that the calls
84    /// can always be resolved.
85    Force {
86        attr_span: Span,
87        reason: Option<Symbol>,
88    },
89}
90
91impl InlineAttr {
92    pub fn always(&self) -> bool {
93        match self {
94            InlineAttr::Always | InlineAttr::Force { .. } => true,
95            InlineAttr::None | InlineAttr::Hint | InlineAttr::Never => false,
96        }
97    }
98}
99
100#[derive(#[automatically_derived]impl ::core::marker::Copy for UnrollAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for UnrollAttr {
}
#[automatically_derived]impl ::core::clone::Clone for UnrollAttr {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<u32>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    UnrollAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for UnrollAttr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Count(__self_0), Self::Count(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for UnrollAttr {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        UnrollAttr::Hint => { 0usize }
                        UnrollAttr::Full => { 1usize }
                        UnrollAttr::Never => { 2usize }
                        UnrollAttr::Count(ref __binding_0) => { 3usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    UnrollAttr::Hint => {}
                    UnrollAttr::Full => {}
                    UnrollAttr::Never => {}
                    UnrollAttr::Count(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for UnrollAttr {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { UnrollAttr::Hint }
                    1usize => { UnrollAttr::Full }
                    2usize => { UnrollAttr::Never }
                    3usize => {
                        UnrollAttr::Count(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `UnrollAttr`, expected 0..4, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for UnrollAttr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Hint => ::core::fmt::Formatter::write_str(f, "Hint"),
            Self::Full => ::core::fmt::Formatter::write_str(f, "Full"),
            Self::Never => ::core::fmt::Formatter::write_str(f, "Never"),
            Self::Count(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Count",
                    &__self_0),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for UnrollAttr {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    UnrollAttr::Hint => 0u8.stable_hash(__hcx, __hasher),
                    UnrollAttr::Full => 1u8.stable_hash(__hcx, __hasher),
                    UnrollAttr::Never => 2u8.stable_hash(__hcx, __hasher),
                    UnrollAttr::Count(ref __binding_0) =>
                        3u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    UnrollAttr::Hint => {}
                    UnrollAttr::Full => {}
                    UnrollAttr::Never => {}
                    UnrollAttr::Count(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for UnrollAttr {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Hint => { __p.word("Hint") }
                    Self::Full => { __p.word("Full") }
                    Self::Never => { __p.word("Never") }
                    Self::Count(f0) => {
                        __p.word("Count");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute)]
101pub enum UnrollAttr {
102    Hint,
103    Full,
104    Never,
105    Count(u32),
106}
107
108#[derive(#[automatically_derived]impl ::core::marker::Copy for InstructionSetAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for InstructionSetAttr {
}
#[automatically_derived]impl ::core::clone::Clone for InstructionSetAttr {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for InstructionSetAttr {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        InstructionSetAttr::ArmA32 => { 0usize }
                        InstructionSetAttr::ArmT32 => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for InstructionSetAttr {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { InstructionSetAttr::ArmA32 }
                    1usize => { InstructionSetAttr::ArmT32 }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `InstructionSetAttr`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for InstructionSetAttr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                InstructionSetAttr::ArmA32 => "ArmA32",
                InstructionSetAttr::ArmT32 => "ArmT32",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    InstructionSetAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for InstructionSetAttr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for InstructionSetAttr { }Eq, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            InstructionSetAttr {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    InstructionSetAttr::ArmA32 =>
                        0u8.stable_hash(__hcx, __hasher),
                    InstructionSetAttr::ArmT32 =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    InstructionSetAttr::ArmA32 => {}
                    InstructionSetAttr::ArmT32 => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for InstructionSetAttr {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::ArmA32 => { __p.word("ArmA32") }
                    Self::ArmT32 => { __p.word("ArmT32") }
                }
            }
        }
    };PrintAttribute)]
109pub enum InstructionSetAttr {
110    ArmA32,
111    ArmT32,
112}
113
114#[derive(#[automatically_derived]impl ::core::marker::Copy for InstrumentFnAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for InstrumentFnAttr {
}
#[automatically_derived]impl ::core::clone::Clone for InstrumentFnAttr {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for InstrumentFnAttr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                InstrumentFnAttr::On => "On",
                InstrumentFnAttr::Off => "Off",
            })
    }
}Debug)]
115#[derive(const _: () =
    {
        impl<__E: ::rustc_serialize::Encoder>
            ::rustc_serialize::Encodable<__E> for InstrumentFnAttr {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        InstrumentFnAttr::On => { 0usize }
                        InstrumentFnAttr::Off => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable_NoContext, const _: () =
    {
        impl<__D: ::rustc_serialize::Decoder>
            ::rustc_serialize::Decodable<__D> for InstrumentFnAttr {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { InstrumentFnAttr::On }
                    1usize => { InstrumentFnAttr::Off }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `InstrumentFnAttr`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable_NoContext, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            InstrumentFnAttr {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    InstrumentFnAttr::On => 0u8.stable_hash(__hcx, __hasher),
                    InstrumentFnAttr::Off => 1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    InstrumentFnAttr::On => {}
                    InstrumentFnAttr::Off => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for InstrumentFnAttr {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::On => { __p.word("On") }
                    Self::Off => { __p.word("Off") }
                }
            }
        }
    };PrintAttribute)]
116pub enum InstrumentFnAttr {
117    /// `#[instrument_fn = "on"]`
118    On,
119    /// `#[instrument_fn = "off"]`
120    Off,
121}
122
123#[derive(#[automatically_derived]impl ::core::marker::Copy for OptimizeAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for OptimizeAttr {
}
#[automatically_derived]impl ::core::clone::Clone for OptimizeAttr {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for OptimizeAttr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                OptimizeAttr::Default => "Default",
                OptimizeAttr::DoNotOptimize => "DoNotOptimize",
                OptimizeAttr::Speed => "Speed",
                OptimizeAttr::Size => "Size",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    OptimizeAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for OptimizeAttr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for OptimizeAttr { }Eq, #[automatically_derived]impl ::core::default::Default for OptimizeAttr {
    #[inline]
    fn default() -> Self { Self::Default }
}Default, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for OptimizeAttr {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Default => { __p.word("Default") }
                    Self::DoNotOptimize => { __p.word("DoNotOptimize") }
                    Self::Speed => { __p.word("Speed") }
                    Self::Size => { __p.word("Size") }
                }
            }
        }
    };PrintAttribute)]
124#[derive(const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for OptimizeAttr {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        OptimizeAttr::Default => { 0usize }
                        OptimizeAttr::DoNotOptimize => { 1usize }
                        OptimizeAttr::Speed => { 2usize }
                        OptimizeAttr::Size => { 3usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for OptimizeAttr {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { OptimizeAttr::Default }
                    1usize => { OptimizeAttr::DoNotOptimize }
                    2usize => { OptimizeAttr::Speed }
                    3usize => { OptimizeAttr::Size }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `OptimizeAttr`, expected 0..4, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for OptimizeAttr
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    OptimizeAttr::Default => 0u8.stable_hash(__hcx, __hasher),
                    OptimizeAttr::DoNotOptimize =>
                        1u8.stable_hash(__hcx, __hasher),
                    OptimizeAttr::Speed => 2u8.stable_hash(__hcx, __hasher),
                    OptimizeAttr::Size => 3u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    OptimizeAttr::Default => {}
                    OptimizeAttr::DoNotOptimize => {}
                    OptimizeAttr::Speed => {}
                    OptimizeAttr::Size => {}
                }
            }
        }
    };StableHash)]
125pub enum OptimizeAttr {
126    /// No `#[optimize(..)]` attribute
127    #[default]
128    Default,
129    /// `#[optimize(none)]`
130    DoNotOptimize,
131    /// `#[optimize(speed)]`
132    Speed,
133    /// `#[optimize(size)]`
134    Size,
135}
136
137impl OptimizeAttr {
138    pub fn do_not_optimize(&self) -> bool {
139        #[allow(non_exhaustive_omitted_patterns)] match self {
    Self::DoNotOptimize => true,
    _ => false,
}matches!(self, Self::DoNotOptimize)
140    }
141}
142
143#[derive(
144    #[automatically_derived]impl ::core::marker::StructuralPartialEq for ReprAttr
    {
}
#[automatically_derived]impl ::core::cmp::PartialEq for ReprAttr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::ReprInt(__self_0), Self::ReprInt(__arg1_0)) =>
                    __self_0 == __arg1_0,
                (Self::ReprPacked(__self_0), Self::ReprPacked(__arg1_0)) =>
                    __self_0 == __arg1_0,
                (Self::ReprAlign(__self_0), Self::ReprAlign(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq,
145    #[automatically_derived]impl ::core::cmp::Eq for ReprAttr {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<IntType>;
        let _: ::core::cmp::AssertParamIsEq<Align>;
    }
}Eq,
146    #[automatically_derived]impl ::core::fmt::Debug for ReprAttr {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::ReprInt(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "ReprInt", &__self_0),
            Self::ReprRust =>
                ::core::fmt::Formatter::write_str(f, "ReprRust"),
            Self::ReprC => ::core::fmt::Formatter::write_str(f, "ReprC"),
            Self::ReprPacked(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "ReprPacked", &__self_0),
            Self::ReprSimd =>
                ::core::fmt::Formatter::write_str(f, "ReprSimd"),
            Self::ReprTransparent =>
                ::core::fmt::Formatter::write_str(f, "ReprTransparent"),
            Self::ReprAlign(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "ReprAlign", &__self_0),
        }
    }
}Debug,
147    #[automatically_derived]impl ::core::cmp::PartialOrd for ReprAttr {
    #[inline]
    fn partial_cmp(&self, other: &Self)
        -> ::core::option::Option<::core::cmp::Ordering> {
        ::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
    }
}PartialOrd,
148    #[automatically_derived]impl ::core::cmp::Ord for ReprAttr {
    #[inline]
    fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
        match ::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
                &::core::intrinsics::discriminant_value(other)) {
            ::core::cmp::Ordering::Equal =>
                match (self, other) {
                    (Self::ReprInt(__self_0), Self::ReprInt(__arg1_0)) =>
                        ::core::cmp::Ord::cmp(__self_0, __arg1_0),
                    (Self::ReprPacked(__self_0), Self::ReprPacked(__arg1_0)) =>
                        ::core::cmp::Ord::cmp(__self_0, __arg1_0),
                    (Self::ReprAlign(__self_0), Self::ReprAlign(__arg1_0)) =>
                        ::core::cmp::Ord::cmp(__self_0, __arg1_0),
                    _ => ::core::cmp::Ordering::Equal,
                },
            cmp => cmp,
        }
    }
}Ord,
149    const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for ReprAttr {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        ReprAttr::ReprInt(ref __binding_0) => { 0usize }
                        ReprAttr::ReprRust => { 1usize }
                        ReprAttr::ReprC => { 2usize }
                        ReprAttr::ReprPacked(ref __binding_0) => { 3usize }
                        ReprAttr::ReprSimd => { 4usize }
                        ReprAttr::ReprTransparent => { 5usize }
                        ReprAttr::ReprAlign(ref __binding_0) => { 6usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    ReprAttr::ReprInt(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    ReprAttr::ReprRust => {}
                    ReprAttr::ReprC => {}
                    ReprAttr::ReprPacked(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    ReprAttr::ReprSimd => {}
                    ReprAttr::ReprTransparent => {}
                    ReprAttr::ReprAlign(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable,
150    const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for ReprAttr {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        ReprAttr::ReprInt(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => { ReprAttr::ReprRust }
                    2usize => { ReprAttr::ReprC }
                    3usize => {
                        ReprAttr::ReprPacked(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    4usize => { ReprAttr::ReprSimd }
                    5usize => { ReprAttr::ReprTransparent }
                    6usize => {
                        ReprAttr::ReprAlign(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `ReprAttr`, expected 0..7, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable,
151    #[automatically_derived]impl ::core::marker::Copy for ReprAttr { }Copy,
152    #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for ReprAttr {
}
#[automatically_derived]impl ::core::clone::Clone for ReprAttr {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<IntType>;
        let _: ::core::clone::AssertParamIsClone<Align>;
        *self
    }
}Clone,
153    const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for ReprAttr {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    ReprAttr::ReprInt(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    ReprAttr::ReprRust => 1u8.stable_hash(__hcx, __hasher),
                    ReprAttr::ReprC => 2u8.stable_hash(__hcx, __hasher),
                    ReprAttr::ReprPacked(ref __binding_0) =>
                        3u8.stable_hash(__hcx, __hasher),
                    ReprAttr::ReprSimd => 4u8.stable_hash(__hcx, __hasher),
                    ReprAttr::ReprTransparent =>
                        5u8.stable_hash(__hcx, __hasher),
                    ReprAttr::ReprAlign(ref __binding_0) =>
                        6u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    ReprAttr::ReprInt(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    ReprAttr::ReprRust => {}
                    ReprAttr::ReprC => {}
                    ReprAttr::ReprPacked(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    ReprAttr::ReprSimd => {}
                    ReprAttr::ReprTransparent => {}
                    ReprAttr::ReprAlign(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash,
154    const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for ReprAttr {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::ReprInt(f0) => {
                        __p.word("ReprInt");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::ReprRust => { __p.word("ReprRust") }
                    Self::ReprC => { __p.word("ReprC") }
                    Self::ReprPacked(f0) => {
                        __p.word("ReprPacked");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::ReprSimd => { __p.word("ReprSimd") }
                    Self::ReprTransparent => { __p.word("ReprTransparent") }
                    Self::ReprAlign(f0) => {
                        __p.word("ReprAlign");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute
155)]
156pub enum ReprAttr {
157    ReprInt(IntType),
158    ReprRust,
159    ReprC,
160    ReprPacked(Align),
161    ReprSimd,
162    ReprTransparent,
163    ReprAlign(Align),
164}
165
166#[derive(#[automatically_derived]impl ::core::cmp::Eq for IntType {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<ast::IntTy>;
        let _: ::core::cmp::AssertParamIsEq<ast::UintTy>;
    }
}Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for IntType {
}
#[automatically_derived]impl ::core::cmp::PartialEq for IntType {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::SignedInt(__self_0), Self::SignedInt(__arg1_0)) =>
                    __self_0 == __arg1_0,
                (Self::UnsignedInt(__self_0), Self::UnsignedInt(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => unsafe { ::core::intrinsics::unreachable() }
            }
    }
}PartialEq, #[automatically_derived]impl ::core::fmt::Debug for IntType {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::SignedInt(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "SignedInt", &__self_0),
            Self::UnsignedInt(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "UnsignedInt", &__self_0),
        }
    }
}Debug, #[automatically_derived]impl ::core::marker::Copy for IntType { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for IntType {
}
#[automatically_derived]impl ::core::clone::Clone for IntType {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<ast::IntTy>;
        let _: ::core::clone::AssertParamIsClone<ast::UintTy>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::cmp::PartialOrd for IntType {
    #[inline]
    fn partial_cmp(&self, other: &Self)
        -> ::core::option::Option<::core::cmp::Ordering> {
        ::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
    }
}PartialOrd, #[automatically_derived]impl ::core::cmp::Ord for IntType {
    #[inline]
    fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
        match (self, other) {
            (Self::SignedInt(__self_0), Self::SignedInt(__arg1_0)) =>
                ::core::cmp::Ord::cmp(__self_0, __arg1_0),
            (Self::UnsignedInt(__self_0), Self::UnsignedInt(__arg1_0)) =>
                ::core::cmp::Ord::cmp(__self_0, __arg1_0),
            _ =>
                ::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
                    &::core::intrinsics::discriminant_value(other)),
        }
    }
}Ord)]
167#[derive(const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for IntType {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        IntType::SignedInt(ref __binding_0) => { 0usize }
                        IntType::UnsignedInt(ref __binding_0) => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    IntType::SignedInt(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    IntType::UnsignedInt(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for IntType {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        IntType::SignedInt(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => {
                        IntType::UnsignedInt(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `IntType`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for IntType {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    IntType::SignedInt(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    IntType::UnsignedInt(ref __binding_0) =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    IntType::SignedInt(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    IntType::UnsignedInt(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for IntType {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::SignedInt(f0) => {
                        __p.word("SignedInt");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::UnsignedInt(f0) => {
                        __p.word("UnsignedInt");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute)]
168pub enum IntType {
169    SignedInt(ast::IntTy),
170    UnsignedInt(ast::UintTy),
171}
172
173#[derive(#[automatically_derived]impl ::core::marker::Copy for Deprecation { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Deprecation {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field3_finish(f,
            "Deprecation since note suggestion", &self.since, &self.note,
            &&self.suggestion)
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Deprecation {
            fn encode(&self, __encoder: &mut __E) {
                let Deprecation {
                        since: ref __binding_0,
                        note: ref __binding_1,
                        suggestion: ref __binding_2 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Deprecation {
            fn decode(__decoder: &mut __D) -> Self {
                Deprecation {
                    since: ::rustc_serialize::Decodable::decode(__decoder),
                    note: ::rustc_serialize::Decodable::decode(__decoder),
                    suggestion: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for Deprecation {
}
#[automatically_derived]impl ::core::clone::Clone for Deprecation {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<DeprecatedSince>;
        let _: ::core::clone::AssertParamIsClone<Option<Ident>>;
        let _: ::core::clone::AssertParamIsClone<Option<Symbol>>;
        *self
    }
}Clone, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for Deprecation
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    Deprecation {
                        since: ref __binding_0,
                        note: ref __binding_1,
                        suggestion: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for Deprecation {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { since, note, suggestion } = self;
                __p.word("Deprecation");
                if true && !since.should_render() && !note.should_render() &&
                        !suggestion.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if since.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("since");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                since.print_attribute(__p);
                if note.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("note");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                note.print_attribute(__p);
                if suggestion.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("suggestion");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                suggestion.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
174pub struct Deprecation {
175    pub since: DeprecatedSince,
176    /// The note to issue a reason.
177    pub note: Option<Ident>,
178    /// A text snippet used to completely replace any use of the deprecated item in an expression.
179    ///
180    /// This is currently unstable.
181    pub suggestion: Option<Symbol>,
182}
183
184/// Release in which an API is deprecated.
185#[derive(#[automatically_derived]impl ::core::marker::Copy for DeprecatedSince { }Copy, #[automatically_derived]impl ::core::fmt::Debug for DeprecatedSince {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::RustcVersion(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcVersion", &__self_0),
            Self::Future => ::core::fmt::Formatter::write_str(f, "Future"),
            Self::NonStandard(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "NonStandard", &__self_0),
            Self::Unspecified =>
                ::core::fmt::Formatter::write_str(f, "Unspecified"),
            Self::Err => ::core::fmt::Formatter::write_str(f, "Err"),
        }
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for DeprecatedSince {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        DeprecatedSince::RustcVersion(ref __binding_0) => { 0usize }
                        DeprecatedSince::Future => { 1usize }
                        DeprecatedSince::NonStandard(ref __binding_0) => { 2usize }
                        DeprecatedSince::Unspecified => { 3usize }
                        DeprecatedSince::Err => { 4usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    DeprecatedSince::RustcVersion(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    DeprecatedSince::Future => {}
                    DeprecatedSince::NonStandard(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    DeprecatedSince::Unspecified => {}
                    DeprecatedSince::Err => {}
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DeprecatedSince {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        DeprecatedSince::RustcVersion(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => { DeprecatedSince::Future }
                    2usize => {
                        DeprecatedSince::NonStandard(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    3usize => { DeprecatedSince::Unspecified }
                    4usize => { DeprecatedSince::Err }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DeprecatedSince`, expected 0..5, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for DeprecatedSince {
}
#[automatically_derived]impl ::core::clone::Clone for DeprecatedSince {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<RustcVersion>;
        let _: ::core::clone::AssertParamIsClone<Symbol>;
        *self
    }
}Clone, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            DeprecatedSince {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DeprecatedSince::RustcVersion(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    DeprecatedSince::Future => 1u8.stable_hash(__hcx, __hasher),
                    DeprecatedSince::NonStandard(ref __binding_0) =>
                        2u8.stable_hash(__hcx, __hasher),
                    DeprecatedSince::Unspecified =>
                        3u8.stable_hash(__hcx, __hasher),
                    DeprecatedSince::Err => 4u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    DeprecatedSince::RustcVersion(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    DeprecatedSince::Future => {}
                    DeprecatedSince::NonStandard(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    DeprecatedSince::Unspecified => {}
                    DeprecatedSince::Err => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DeprecatedSince {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::RustcVersion(f0) => {
                        __p.word("RustcVersion");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Future => { __p.word("Future") }
                    Self::NonStandard(f0) => {
                        __p.word("NonStandard");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Unspecified => { __p.word("Unspecified") }
                    Self::Err => { __p.word("Err") }
                }
            }
        }
    };PrintAttribute)]
186pub enum DeprecatedSince {
187    RustcVersion(RustcVersion),
188    /// Deprecated in the future ("to be determined").
189    Future,
190    /// `feature(staged_api)` is off. Deprecation versions outside the standard
191    /// library are allowed to be arbitrary strings, for better or worse.
192    NonStandard(Symbol),
193    /// Deprecation version is unspecified but optional.
194    Unspecified,
195    /// Failed to parse a deprecation version, or the deprecation version is
196    /// unspecified and required. An error has already been emitted.
197    Err,
198}
199
200/// Successfully-parsed value of a `#[coverage(..)]` attribute.
201#[derive(#[automatically_derived]impl ::core::marker::Copy for CoverageAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for CoverageAttrKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                CoverageAttrKind::On => "On",
                CoverageAttrKind::Off => "Off",
            })
    }
}Debug, #[automatically_derived]impl ::core::cmp::Eq for CoverageAttrKind { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    CoverageAttrKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for CoverageAttrKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for CoverageAttrKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        CoverageAttrKind::On => { 0usize }
                        CoverageAttrKind::Off => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for CoverageAttrKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { CoverageAttrKind::On }
                    1usize => { CoverageAttrKind::Off }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `CoverageAttrKind`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for CoverageAttrKind {
}
#[automatically_derived]impl ::core::clone::Clone for CoverageAttrKind {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone)]
202#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            CoverageAttrKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    CoverageAttrKind::On => 0u8.stable_hash(__hcx, __hasher),
                    CoverageAttrKind::Off => 1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    CoverageAttrKind::On => {}
                    CoverageAttrKind::Off => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for CoverageAttrKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::On => { __p.word("On") }
                    Self::Off => { __p.word("Off") }
                }
            }
        }
    };PrintAttribute)]
203pub enum CoverageAttrKind {
204    On,
205    Off,
206}
207
208/// Successfully-parsed value of a `#[rustc_abi(..)]` attribute.
209#[derive(#[automatically_derived]impl ::core::marker::Copy for RustcAbiAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RustcAbiAttrKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                RustcAbiAttrKind::Debug => "Debug",
                RustcAbiAttrKind::AssertEq => "AssertEq",
            })
    }
}Debug, #[automatically_derived]impl ::core::cmp::Eq for RustcAbiAttrKind { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RustcAbiAttrKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcAbiAttrKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcAbiAttrKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        RustcAbiAttrKind::Debug => { 0usize }
                        RustcAbiAttrKind::AssertEq => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcAbiAttrKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { RustcAbiAttrKind::Debug }
                    1usize => { RustcAbiAttrKind::AssertEq }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcAbiAttrKind`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for RustcAbiAttrKind {
}
#[automatically_derived]impl ::core::clone::Clone for RustcAbiAttrKind {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone)]
210#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcAbiAttrKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcAbiAttrKind::Debug => 0u8.stable_hash(__hcx, __hasher),
                    RustcAbiAttrKind::AssertEq =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RustcAbiAttrKind::Debug => {}
                    RustcAbiAttrKind::AssertEq => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcAbiAttrKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Debug => { __p.word("Debug") }
                    Self::AssertEq => { __p.word("AssertEq") }
                }
            }
        }
    };PrintAttribute)]
211pub enum RustcAbiAttrKind {
212    Debug,
213    AssertEq,
214}
215
216impl Deprecation {
217    /// Whether an item marked with #[deprecated(since = "X")] is currently
218    /// deprecated (i.e., whether X is not greater than the current rustc
219    /// version).
220    pub fn is_in_effect(&self) -> bool {
221        match self.since {
222            DeprecatedSince::RustcVersion(since) => since <= RustcVersion::CURRENT,
223            DeprecatedSince::Future => false,
224            // The `since` field doesn't have semantic purpose without `#![staged_api]`.
225            DeprecatedSince::NonStandard(_) => true,
226            // Assume deprecation is in effect if "since" field is absent or invalid.
227            DeprecatedSince::Unspecified | DeprecatedSince::Err => true,
228        }
229    }
230
231    pub fn is_since_rustc_version(&self) -> bool {
232        #[allow(non_exhaustive_omitted_patterns)] match self.since {
    DeprecatedSince::RustcVersion(_) => true,
    _ => false,
}matches!(self.since, DeprecatedSince::RustcVersion(_))
233    }
234}
235
236/// There are three valid forms of the attribute:
237/// `#[used]`, which is equivalent to `#[used(linker)]` on targets that support it, but `#[used(compiler)]` if not.
238/// `#[used(compiler)]`
239/// `#[used(linker)]`
240#[derive(const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for UsedBy {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        UsedBy::Default => { 0usize }
                        UsedBy::Compiler => { 1usize }
                        UsedBy::Linker => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for UsedBy {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { UsedBy::Default }
                    1usize => { UsedBy::Compiler }
                    2usize => { UsedBy::Linker }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `UsedBy`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::marker::Copy for UsedBy { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for UsedBy {
}
#[automatically_derived]impl ::core::clone::Clone for UsedBy {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for UsedBy {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                UsedBy::Default => "Default",
                UsedBy::Compiler => "Compiler",
                UsedBy::Linker => "Linker",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for UsedBy {
}
#[automatically_derived]impl ::core::cmp::PartialEq for UsedBy {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for UsedBy { }Eq, #[automatically_derived]impl ::core::hash::Hash for UsedBy {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash)]
241#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for UsedBy {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    UsedBy::Default => 0u8.stable_hash(__hcx, __hasher),
                    UsedBy::Compiler => 1u8.stable_hash(__hcx, __hasher),
                    UsedBy::Linker => 2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    UsedBy::Default => {}
                    UsedBy::Compiler => {}
                    UsedBy::Linker => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for UsedBy {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Default => { __p.word("Default") }
                    Self::Compiler => { __p.word("Compiler") }
                    Self::Linker => { __p.word("Linker") }
                }
            }
        }
    };PrintAttribute)]
242pub enum UsedBy {
243    Default,
244    Compiler,
245    Linker,
246}
247
248#[derive(const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for MacroUseArgs {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        MacroUseArgs::UseAll => { 0usize }
                        MacroUseArgs::UseSpecific(ref __binding_0) => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    MacroUseArgs::UseAll => {}
                    MacroUseArgs::UseSpecific(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for MacroUseArgs {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { MacroUseArgs::UseAll }
                    1usize => {
                        MacroUseArgs::UseSpecific(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `MacroUseArgs`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::clone::Clone for MacroUseArgs {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::UseAll => MacroUseArgs::UseAll,
            Self::UseSpecific(__self_0) =>
                MacroUseArgs::UseSpecific(::core::clone::Clone::clone(__self_0)),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for MacroUseArgs {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::UseAll => ::core::fmt::Formatter::write_str(f, "UseAll"),
            Self::UseSpecific(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "UseSpecific", &__self_0),
        }
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    MacroUseArgs {
}
#[automatically_derived]impl ::core::cmp::PartialEq for MacroUseArgs {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::UseSpecific(__self_0), Self::UseSpecific(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for MacroUseArgs {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<ThinVec<Ident>>;
    }
}Eq, #[automatically_derived]impl ::core::hash::Hash for MacroUseArgs {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state);
        match self {
            Self::UseSpecific(__self_0) =>
                ::core::hash::Hash::hash(__self_0, state),
            _ => {}
        }
    }
}Hash)]
249#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for MacroUseArgs
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    MacroUseArgs::UseAll => 0u8.stable_hash(__hcx, __hasher),
                    MacroUseArgs::UseSpecific(ref __binding_0) =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    MacroUseArgs::UseAll => {}
                    MacroUseArgs::UseSpecific(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for MacroUseArgs {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::UseAll => { __p.word("UseAll") }
                    Self::UseSpecific(f0) => {
                        __p.word("UseSpecific");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute)]
250pub enum MacroUseArgs {
251    UseAll,
252    UseSpecific(ThinVec<Ident>),
253}
254
255impl Default for MacroUseArgs {
256    fn default() -> Self {
257        Self::UseSpecific(ThinVec::new())
258    }
259}
260
261#[derive(#[automatically_derived]impl<ScopeId: ::core::fmt::Debug> ::core::fmt::Debug
    for StrippedCfgItem<ScopeId> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field3_finish(f,
            "StrippedCfgItem parent_scope ident cfg", &self.parent_scope,
            &self.ident, &&self.cfg)
    }
}Debug, #[automatically_derived]impl<ScopeId: ::core::clone::Clone>
    ::core::clone::Clone for StrippedCfgItem<ScopeId> {
    #[inline]
    fn clone(&self) -> Self {
        StrippedCfgItem {
            parent_scope: ::core::clone::Clone::clone(&self.parent_scope),
            ident: ::core::clone::Clone::clone(&self.ident),
            cfg: ::core::clone::Clone::clone(&self.cfg),
        }
    }
}Clone, const _: () =
    {
        impl<ScopeId, __E: ::rustc_span::SpanEncoder>
            ::rustc_serialize::Encodable<__E> for StrippedCfgItem<ScopeId>
            where ScopeId: ::rustc_serialize::Encodable<__E> {
            fn encode(&self, __encoder: &mut __E) {
                let StrippedCfgItem {
                        parent_scope: ref __binding_0,
                        ident: ref __binding_1,
                        cfg: ref __binding_2 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<ScopeId, __D: ::rustc_span::SpanDecoder>
            ::rustc_serialize::Decodable<__D> for StrippedCfgItem<ScopeId>
            where ScopeId: ::rustc_serialize::Decodable<__D> {
            fn decode(__decoder: &mut __D) -> Self {
                StrippedCfgItem {
                    parent_scope: ::rustc_serialize::Decodable::decode(__decoder),
                    ident: ::rustc_serialize::Decodable::decode(__decoder),
                    cfg: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        impl<ScopeId> ::rustc_data_structures::stable_hash::StableHash for
            StrippedCfgItem<ScopeId> where
            ScopeId: ::rustc_data_structures::stable_hash::StableHash {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    StrippedCfgItem {
                        parent_scope: ref __binding_0,
                        ident: ref __binding_1,
                        cfg: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash)]
262pub struct StrippedCfgItem<ScopeId = DefId> {
263    pub parent_scope: ScopeId,
264    pub ident: Ident,
265    pub cfg: (CfgEntry, Span),
266}
267
268impl<ScopeId> StrippedCfgItem<ScopeId> {
269    pub fn map_scope_id<New>(self, f: impl FnOnce(ScopeId) -> New) -> StrippedCfgItem<New> {
270        StrippedCfgItem { parent_scope: f(self.parent_scope), ident: self.ident, cfg: self.cfg }
271    }
272}
273
274/// Possible values for the `#[linkage]` attribute, allowing to specify the
275/// linkage type for a `MonoItem`.
276///
277/// See <https://llvm.org/docs/LangRef.html#linkage-types> for more details about these variants.
278#[derive(const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Linkage {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        Linkage::AvailableExternally => { 0usize }
                        Linkage::ExternalWeak => { 1usize }
                        Linkage::External => { 2usize }
                        Linkage::Internal => { 3usize }
                        Linkage::LinkOnceAny => { 4usize }
                        Linkage::LinkOnceODR => { 5usize }
                        Linkage::WeakAny => { 6usize }
                        Linkage::WeakODR => { 7usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Linkage {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { Linkage::AvailableExternally }
                    1usize => { Linkage::ExternalWeak }
                    2usize => { Linkage::External }
                    3usize => { Linkage::Internal }
                    4usize => { Linkage::LinkOnceAny }
                    5usize => { Linkage::LinkOnceODR }
                    6usize => { Linkage::WeakAny }
                    7usize => { Linkage::WeakODR }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `Linkage`, expected 0..8, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for Linkage {
}
#[automatically_derived]impl ::core::clone::Clone for Linkage {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for Linkage { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Linkage {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "AvailableExternally ExternalWeak External Internal LinkOnceAny LinkOnceODR WeakAny WeakODR",
            match self {
                Linkage::AvailableExternally => 0usize,
                Linkage::ExternalWeak => 20usize,
                Linkage::External => 33usize,
                Linkage::Internal => 42usize,
                Linkage::LinkOnceAny => 51usize,
                Linkage::LinkOnceODR => 63usize,
                Linkage::WeakAny => 75usize,
                Linkage::WeakODR => 83usize,
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for Linkage {
}
#[automatically_derived]impl ::core::cmp::PartialEq for Linkage {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for Linkage { }Eq, #[automatically_derived]impl ::core::hash::Hash for Linkage {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash)]
279#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for Linkage {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    Linkage::AvailableExternally =>
                        0u8.stable_hash(__hcx, __hasher),
                    Linkage::ExternalWeak => 1u8.stable_hash(__hcx, __hasher),
                    Linkage::External => 2u8.stable_hash(__hcx, __hasher),
                    Linkage::Internal => 3u8.stable_hash(__hcx, __hasher),
                    Linkage::LinkOnceAny => 4u8.stable_hash(__hcx, __hasher),
                    Linkage::LinkOnceODR => 5u8.stable_hash(__hcx, __hasher),
                    Linkage::WeakAny => 6u8.stable_hash(__hcx, __hasher),
                    Linkage::WeakODR => 7u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    Linkage::AvailableExternally => {}
                    Linkage::ExternalWeak => {}
                    Linkage::External => {}
                    Linkage::Internal => {}
                    Linkage::LinkOnceAny => {}
                    Linkage::LinkOnceODR => {}
                    Linkage::WeakAny => {}
                    Linkage::WeakODR => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for Linkage {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::AvailableExternally => {
                        __p.word("AvailableExternally")
                    }
                    Self::ExternalWeak => { __p.word("ExternalWeak") }
                    Self::External => { __p.word("External") }
                    Self::Internal => { __p.word("Internal") }
                    Self::LinkOnceAny => { __p.word("LinkOnceAny") }
                    Self::LinkOnceODR => { __p.word("LinkOnceODR") }
                    Self::WeakAny => { __p.word("WeakAny") }
                    Self::WeakODR => { __p.word("WeakODR") }
                }
            }
        }
    };PrintAttribute)]
280pub enum Linkage {
281    AvailableExternally,
282    ExternalWeak,
283    External,
284    Internal,
285    LinkOnceAny,
286    LinkOnceODR,
287    WeakAny,
288    WeakODR,
289}
290
291#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for MirDialect {
}
#[automatically_derived]impl ::core::clone::Clone for MirDialect {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for MirDialect { }Copy, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for MirDialect {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { MirDialect::Analysis }
                    1usize => { MirDialect::Built }
                    2usize => { MirDialect::Runtime }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `MirDialect`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for MirDialect {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                MirDialect::Analysis => "Analysis",
                MirDialect::Built => "Built",
                MirDialect::Runtime => "Runtime",
            })
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for MirDialect {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        MirDialect::Analysis => { 0usize }
                        MirDialect::Built => { 1usize }
                        MirDialect::Runtime => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    MirDialect {
}
#[automatically_derived]impl ::core::cmp::PartialEq for MirDialect {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq)]
292#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for MirDialect {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    MirDialect::Analysis => 0u8.stable_hash(__hcx, __hasher),
                    MirDialect::Built => 1u8.stable_hash(__hcx, __hasher),
                    MirDialect::Runtime => 2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    MirDialect::Analysis => {}
                    MirDialect::Built => {}
                    MirDialect::Runtime => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for MirDialect {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Analysis => { __p.word("Analysis") }
                    Self::Built => { __p.word("Built") }
                    Self::Runtime => { __p.word("Runtime") }
                }
            }
        }
    };PrintAttribute)]
293pub enum MirDialect {
294    Analysis,
295    Built,
296    Runtime,
297}
298
299impl IntoDiagArg for MirDialect {
300    fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
301        let arg = match self {
302            MirDialect::Analysis => "analysis",
303            MirDialect::Built => "built",
304            MirDialect::Runtime => "runtime",
305        };
306        DiagArgValue::Str(Cow::Borrowed(arg))
307    }
308}
309
310#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for MirPhase {
}
#[automatically_derived]impl ::core::clone::Clone for MirPhase {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for MirPhase { }Copy, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for MirPhase {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { MirPhase::Initial }
                    1usize => { MirPhase::PostCleanup }
                    2usize => { MirPhase::Optimized }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `MirPhase`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for MirPhase {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                MirPhase::Initial => "Initial",
                MirPhase::PostCleanup => "PostCleanup",
                MirPhase::Optimized => "Optimized",
            })
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for MirPhase {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        MirPhase::Initial => { 0usize }
                        MirPhase::PostCleanup => { 1usize }
                        MirPhase::Optimized => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, #[automatically_derived]impl ::core::marker::StructuralPartialEq for MirPhase
    {
}
#[automatically_derived]impl ::core::cmp::PartialEq for MirPhase {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq)]
311#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for MirPhase {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    MirPhase::Initial => 0u8.stable_hash(__hcx, __hasher),
                    MirPhase::PostCleanup => 1u8.stable_hash(__hcx, __hasher),
                    MirPhase::Optimized => 2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    MirPhase::Initial => {}
                    MirPhase::PostCleanup => {}
                    MirPhase::Optimized => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for MirPhase {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Initial => { __p.word("Initial") }
                    Self::PostCleanup => { __p.word("PostCleanup") }
                    Self::Optimized => { __p.word("Optimized") }
                }
            }
        }
    };PrintAttribute)]
312pub enum MirPhase {
313    Initial,
314    PostCleanup,
315    Optimized,
316}
317
318impl IntoDiagArg for MirPhase {
319    fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
320        let arg = match self {
321            MirPhase::Initial => "initial",
322            MirPhase::PostCleanup => "post-cleanup",
323            MirPhase::Optimized => "optimized",
324        };
325        DiagArgValue::Str(Cow::Borrowed(arg))
326    }
327}
328
329/// Different ways that the PE Format can decorate a symbol name.
330/// From <https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-name-type>
331#[derive(#[automatically_derived]impl ::core::marker::Copy for PeImportNameType { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for PeImportNameType {
}
#[automatically_derived]impl ::core::clone::Clone for PeImportNameType {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<u16>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for PeImportNameType {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Ordinal(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Ordinal", &__self_0),
            Self::Decorated =>
                ::core::fmt::Formatter::write_str(f, "Decorated"),
            Self::NoPrefix =>
                ::core::fmt::Formatter::write_str(f, "NoPrefix"),
            Self::Undecorated =>
                ::core::fmt::Formatter::write_str(f, "Undecorated"),
        }
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for PeImportNameType {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        PeImportNameType::Ordinal(ref __binding_0) => { 0usize }
                        PeImportNameType::Decorated => { 1usize }
                        PeImportNameType::NoPrefix => { 2usize }
                        PeImportNameType::Undecorated => { 3usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    PeImportNameType::Ordinal(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    PeImportNameType::Decorated => {}
                    PeImportNameType::NoPrefix => {}
                    PeImportNameType::Undecorated => {}
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for PeImportNameType {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        PeImportNameType::Ordinal(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => { PeImportNameType::Decorated }
                    2usize => { PeImportNameType::NoPrefix }
                    3usize => { PeImportNameType::Undecorated }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `PeImportNameType`, expected 0..4, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            PeImportNameType {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    PeImportNameType::Ordinal(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    PeImportNameType::Decorated =>
                        1u8.stable_hash(__hcx, __hasher),
                    PeImportNameType::NoPrefix =>
                        2u8.stable_hash(__hcx, __hasher),
                    PeImportNameType::Undecorated =>
                        3u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    PeImportNameType::Ordinal(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    PeImportNameType::Decorated => {}
                    PeImportNameType::NoPrefix => {}
                    PeImportNameType::Undecorated => {}
                }
            }
        }
    };StableHash, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    PeImportNameType {
}
#[automatically_derived]impl ::core::cmp::PartialEq for PeImportNameType {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Ordinal(__self_0), Self::Ordinal(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for PeImportNameType {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<u16>;
    }
}Eq, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for PeImportNameType {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Ordinal(f0) => {
                        __p.word("Ordinal");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Decorated => { __p.word("Decorated") }
                    Self::NoPrefix => { __p.word("NoPrefix") }
                    Self::Undecorated => { __p.word("Undecorated") }
                }
            }
        }
    };PrintAttribute)]
332pub enum PeImportNameType {
333    /// IMPORT_ORDINAL
334    /// Uses the ordinal (i.e., a number) rather than the name.
335    Ordinal(u16),
336    /// Same as IMPORT_NAME
337    /// Name is decorated with all prefixes and suffixes.
338    Decorated,
339    /// Same as IMPORT_NAME_NOPREFIX
340    /// Prefix (e.g., the leading `_` or `@`) is skipped, but suffix is kept.
341    NoPrefix,
342    /// Same as IMPORT_NAME_UNDECORATE
343    /// Prefix (e.g., the leading `_` or `@`) and suffix (the first `@` and all
344    /// trailing characters) are skipped.
345    Undecorated,
346}
347
348#[derive(#[automatically_derived]impl ::core::fmt::Debug for LinkEntry {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        let names: &'static _ =
            "LinkEntry span kind name cfg verbatim import_name_type";
        let values: &[&dyn ::core::fmt::Debug] =
            &[&self.span, &self.kind, &self.name, &self.cfg, &self.verbatim,
                        &&self.import_name_type];
        ::core::fmt::Formatter::debug_struct_fields_finish(f, names, values)
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for LinkEntry {
            fn encode(&self, __encoder: &mut __E) {
                let LinkEntry {
                        span: ref __binding_0,
                        kind: ref __binding_1,
                        name: ref __binding_2,
                        cfg: ref __binding_3,
                        verbatim: ref __binding_4,
                        import_name_type: ref __binding_5 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_4,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_5,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for LinkEntry {
            fn decode(__decoder: &mut __D) -> Self {
                LinkEntry {
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                    kind: ::rustc_serialize::Decodable::decode(__decoder),
                    name: ::rustc_serialize::Decodable::decode(__decoder),
                    cfg: ::rustc_serialize::Decodable::decode(__decoder),
                    verbatim: ::rustc_serialize::Decodable::decode(__decoder),
                    import_name_type: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::clone::Clone for LinkEntry {
    #[inline]
    fn clone(&self) -> Self {
        LinkEntry {
            span: ::core::clone::Clone::clone(&self.span),
            kind: ::core::clone::Clone::clone(&self.kind),
            name: ::core::clone::Clone::clone(&self.name),
            cfg: ::core::clone::Clone::clone(&self.cfg),
            verbatim: ::core::clone::Clone::clone(&self.verbatim),
            import_name_type: ::core::clone::Clone::clone(&self.import_name_type),
        }
    }
}Clone, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for LinkEntry {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    LinkEntry {
                        span: ref __binding_0,
                        kind: ref __binding_1,
                        name: ref __binding_2,
                        cfg: ref __binding_3,
                        verbatim: ref __binding_4,
                        import_name_type: ref __binding_5 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                        { __binding_4.stable_hash(__hcx, __hasher); }
                        { __binding_5.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for LinkEntry {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { span, kind, name, cfg, verbatim, import_name_type
                        } = self;
                __p.word("LinkEntry");
                if true && !span.should_render() && !kind.should_render() &&
                                    !name.should_render() && !cfg.should_render() &&
                            !verbatim.should_render() &&
                        !import_name_type.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                span.print_attribute(__p);
                if kind.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("kind");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                kind.print_attribute(__p);
                if name.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("name");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                name.print_attribute(__p);
                if cfg.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("cfg");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                cfg.print_attribute(__p);
                if verbatim.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("verbatim");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                verbatim.print_attribute(__p);
                if import_name_type.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("import_name_type");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                import_name_type.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
349pub struct LinkEntry {
350    pub span: Span,
351    pub kind: NativeLibKind,
352    pub name: Symbol,
353    pub cfg: Option<CfgEntry>,
354    pub verbatim: Option<bool>,
355    pub import_name_type: Option<(PeImportNameType, Span)>,
356}
357
358#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            DebuggerVisualizerType {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DebuggerVisualizerType::Natvis =>
                        0u8.stable_hash(__hcx, __hasher),
                    DebuggerVisualizerType::GdbPrettyPrinter =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    DebuggerVisualizerType::Natvis => {}
                    DebuggerVisualizerType::GdbPrettyPrinter => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DebuggerVisualizerType {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Natvis => { __p.word("Natvis") }
                    Self::GdbPrettyPrinter => { __p.word("GdbPrettyPrinter") }
                }
            }
        }
    };PrintAttribute)]
359#[derive(#[automatically_derived]impl ::core::marker::Copy for DebuggerVisualizerType {
}Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    DebuggerVisualizerType {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DebuggerVisualizerType
    {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::PartialOrd for
    DebuggerVisualizerType {
    #[inline]
    fn partial_cmp(&self, other: &Self)
        -> ::core::option::Option<::core::cmp::Ordering> {
        ::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
    }
}PartialOrd, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for DebuggerVisualizerType {
}
#[automatically_derived]impl ::core::clone::Clone for DebuggerVisualizerType {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::cmp::Ord for DebuggerVisualizerType {
    #[inline]
    fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
        ::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
            &::core::intrinsics::discriminant_value(other))
    }
}Ord, #[automatically_derived]impl ::core::cmp::Eq for DebuggerVisualizerType { }Eq, #[automatically_derived]impl ::core::hash::Hash for DebuggerVisualizerType {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash, #[automatically_derived]impl ::core::fmt::Debug for DebuggerVisualizerType {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                DebuggerVisualizerType::Natvis => "Natvis",
                DebuggerVisualizerType::GdbPrettyPrinter =>
                    "GdbPrettyPrinter",
            })
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for DebuggerVisualizerType {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        DebuggerVisualizerType::Natvis => { 0usize }
                        DebuggerVisualizerType::GdbPrettyPrinter => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DebuggerVisualizerType {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { DebuggerVisualizerType::Natvis }
                    1usize => { DebuggerVisualizerType::GdbPrettyPrinter }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DebuggerVisualizerType`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
360pub enum DebuggerVisualizerType {
361    Natvis,
362    GdbPrettyPrinter,
363}
364
365#[derive(#[automatically_derived]impl ::core::fmt::Debug for DebugVisualizer {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field3_finish(f,
            "DebugVisualizer span visualizer_type path", &self.span,
            &self.visualizer_type, &&self.path)
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for DebugVisualizer {
            fn encode(&self, __encoder: &mut __E) {
                let DebugVisualizer {
                        span: ref __binding_0,
                        visualizer_type: ref __binding_1,
                        path: ref __binding_2 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DebugVisualizer {
            fn decode(__decoder: &mut __D) -> Self {
                DebugVisualizer {
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                    visualizer_type: ::rustc_serialize::Decodable::decode(__decoder),
                    path: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::clone::Clone for DebugVisualizer {
    #[inline]
    fn clone(&self) -> Self {
        DebugVisualizer {
            span: ::core::clone::Clone::clone(&self.span),
            visualizer_type: ::core::clone::Clone::clone(&self.visualizer_type),
            path: ::core::clone::Clone::clone(&self.path),
        }
    }
}Clone, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            DebugVisualizer {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DebugVisualizer {
                        span: ref __binding_0,
                        visualizer_type: ref __binding_1,
                        path: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DebugVisualizer {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { span, visualizer_type, path } = self;
                __p.word("DebugVisualizer");
                if true && !span.should_render() &&
                            !visualizer_type.should_render() && !path.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                span.print_attribute(__p);
                if visualizer_type.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("visualizer_type");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                visualizer_type.print_attribute(__p);
                if path.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("path");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                path.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
366pub struct DebugVisualizer {
367    pub span: Span,
368    pub visualizer_type: DebuggerVisualizerType,
369    pub path: Symbol,
370}
371
372#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for RtsanSetting {
}
#[automatically_derived]impl ::core::clone::Clone for RtsanSetting {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for RtsanSetting { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RtsanSetting {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                RtsanSetting::Nonblocking => "Nonblocking",
                RtsanSetting::Blocking => "Blocking",
                RtsanSetting::Caller => "Caller",
            })
    }
}Debug, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RtsanSetting {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { RtsanSetting::Nonblocking }
                    1usize => { RtsanSetting::Blocking }
                    2usize => { RtsanSetting::Caller }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RtsanSetting`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RtsanSetting {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        RtsanSetting::Nonblocking => { 0usize }
                        RtsanSetting::Blocking => { 1usize }
                        RtsanSetting::Caller => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, #[automatically_derived]impl ::core::cmp::Eq for RtsanSetting { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RtsanSetting {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RtsanSetting {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq)]
373#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for RtsanSetting
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RtsanSetting::Nonblocking =>
                        0u8.stable_hash(__hcx, __hasher),
                    RtsanSetting::Blocking => 1u8.stable_hash(__hcx, __hasher),
                    RtsanSetting::Caller => 2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RtsanSetting::Nonblocking => {}
                    RtsanSetting::Blocking => {}
                    RtsanSetting::Caller => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RtsanSetting {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Nonblocking => { __p.word("Nonblocking") }
                    Self::Blocking => { __p.word("Blocking") }
                    Self::Caller => { __p.word("Caller") }
                }
            }
        }
    };PrintAttribute)]
374#[derive_const(#[automatically_derived]const impl ::core::default::Default for RtsanSetting {
    #[inline]
    fn default() -> Self { Self::Caller }
}Default)]
375pub enum RtsanSetting {
376    Nonblocking,
377    Blocking,
378    #[default]
379    Caller,
380}
381
382#[derive(#[automatically_derived]impl ::core::cmp::Eq for WindowsSubsystemKind { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    WindowsSubsystemKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for WindowsSubsystemKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::fmt::Debug for WindowsSubsystemKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                WindowsSubsystemKind::Console => "Console",
                WindowsSubsystemKind::Windows => "Windows",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::Copy for WindowsSubsystemKind { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for WindowsSubsystemKind {
}
#[automatically_derived]impl ::core::clone::Clone for WindowsSubsystemKind {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone)]
383#[derive(const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for WindowsSubsystemKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        WindowsSubsystemKind::Console => { 0usize }
                        WindowsSubsystemKind::Windows => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for WindowsSubsystemKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { WindowsSubsystemKind::Console }
                    1usize => { WindowsSubsystemKind::Windows }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `WindowsSubsystemKind`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            WindowsSubsystemKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    WindowsSubsystemKind::Console =>
                        0u8.stable_hash(__hcx, __hasher),
                    WindowsSubsystemKind::Windows =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    WindowsSubsystemKind::Console => {}
                    WindowsSubsystemKind::Windows => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for WindowsSubsystemKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Console => { __p.word("Console") }
                    Self::Windows => { __p.word("Windows") }
                }
            }
        }
    };PrintAttribute)]
384pub enum WindowsSubsystemKind {
385    Console,
386    Windows,
387}
388
389impl WindowsSubsystemKind {
390    pub fn as_str(&self) -> &'static str {
391        match self {
392            WindowsSubsystemKind::Console => "console",
393            WindowsSubsystemKind::Windows => "windows",
394        }
395    }
396}
397
398#[derive(#[automatically_derived]impl ::core::marker::Copy for DocInline { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for DocInline {
}
#[automatically_derived]impl ::core::clone::Clone for DocInline {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocInline {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                DocInline::Inline => "Inline",
                DocInline::NoInline => "NoInline",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for DocInline
    {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DocInline {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq)]
399#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for DocInline {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DocInline::Inline => 0u8.stable_hash(__hcx, __hasher),
                    DocInline::NoInline => 1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    DocInline::Inline => {}
                    DocInline::NoInline => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for DocInline {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        DocInline::Inline => { 0usize }
                        DocInline::NoInline => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DocInline {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { DocInline::Inline }
                    1usize => { DocInline::NoInline }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DocInline`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DocInline {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Inline => { __p.word("Inline") }
                    Self::NoInline => { __p.word("NoInline") }
                }
            }
        }
    };PrintAttribute)]
400pub enum DocInline {
401    Inline,
402    NoInline,
403}
404
405#[derive(#[automatically_derived]impl ::core::marker::Copy for HideOrShow { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for HideOrShow {
}
#[automatically_derived]impl ::core::clone::Clone for HideOrShow {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for HideOrShow {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                HideOrShow::Hide => "Hide",
                HideOrShow::Show => "Show",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    HideOrShow {
}
#[automatically_derived]impl ::core::cmp::PartialEq for HideOrShow {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq)]
406#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for HideOrShow {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    HideOrShow::Hide => 0u8.stable_hash(__hcx, __hasher),
                    HideOrShow::Show => 1u8.stable_hash(__hcx, __hasher),
                }
                match *self { HideOrShow::Hide => {} HideOrShow::Show => {} }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for HideOrShow {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        HideOrShow::Hide => { 0usize }
                        HideOrShow::Show => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for HideOrShow {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { HideOrShow::Hide }
                    1usize => { HideOrShow::Show }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `HideOrShow`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for HideOrShow {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Hide => { __p.word("Hide") }
                    Self::Show => { __p.word("Show") }
                }
            }
        }
    };PrintAttribute)]
407pub enum HideOrShow {
408    Hide,
409    Show,
410}
411
412#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for DocCfgHideShowValue {
}
#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShowValue {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<Span>;
        let _: ::core::clone::AssertParamIsClone<Option<Symbol>>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::marker::Copy for DocCfgHideShowValue { }Copy, #[automatically_derived]impl ::core::fmt::Debug for DocCfgHideShowValue {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f,
            "DocCfgHideShowValue span value", &self.span, &&self.value)
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            DocCfgHideShowValue {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DocCfgHideShowValue {
                        span: ref __binding_0, value: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for DocCfgHideShowValue {
            fn encode(&self, __encoder: &mut __E) {
                let DocCfgHideShowValue {
                        span: ref __binding_0, value: ref __binding_1 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DocCfgHideShowValue {
            fn decode(__decoder: &mut __D) -> Self {
                DocCfgHideShowValue {
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                    value: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DocCfgHideShowValue {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { span, value } = self;
                __p.word("DocCfgHideShowValue");
                if true && !span.should_render() && !value.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                span.print_attribute(__p);
                if value.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("value");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                value.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    DocCfgHideShowValue {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DocCfgHideShowValue {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.span == other.span && self.value == other.value
    }
}PartialEq)]
413pub struct DocCfgHideShowValue {
414    pub span: Span,
415    /// If `value` is `None`, then it's a `none()` value.
416    pub value: Option<Symbol>,
417}
418
419impl DocCfgHideShowValue {
420    pub fn new(value: Symbol, span: Span) -> Self {
421        Self { span, value: Some(value) }
422    }
423
424    pub fn new_none(span: Span) -> Self {
425        Self { span, value: None }
426    }
427}
428
429#[derive(#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShow {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::Any(__self_0) =>
                DocCfgHideShow::Any(::core::clone::Clone::clone(__self_0)),
            Self::List(__self_0) =>
                DocCfgHideShow::List(::core::clone::Clone::clone(__self_0)),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocCfgHideShow {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Any(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Any",
                    &__self_0),
            Self::List(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "List",
                    &__self_0),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            DocCfgHideShow {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DocCfgHideShow::Any(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    DocCfgHideShow::List(ref __binding_0) =>
                        1u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    DocCfgHideShow::Any(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    DocCfgHideShow::List(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for DocCfgHideShow {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        DocCfgHideShow::Any(ref __binding_0) => { 0usize }
                        DocCfgHideShow::List(ref __binding_0) => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    DocCfgHideShow::Any(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    DocCfgHideShow::List(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DocCfgHideShow {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        DocCfgHideShow::Any(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => {
                        DocCfgHideShow::List(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DocCfgHideShow`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DocCfgHideShow {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Any(f0) => {
                        __p.word("Any");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::List(f0) => {
                        __p.word("List");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    DocCfgHideShow {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DocCfgHideShow {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Any(__self_0), Self::Any(__arg1_0)) =>
                    __self_0 == __arg1_0,
                (Self::List(__self_0), Self::List(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => unsafe { ::core::intrinsics::unreachable() }
            }
    }
}PartialEq)]
430pub enum DocCfgHideShow {
431    Any(Span),
432    List(ThinVec<DocCfgHideShowValue>),
433}
434
435impl DocCfgHideShow {
436    pub fn new() -> Self {
437        Self::List(ThinVec::new())
438    }
439
440    pub fn new_with_only_key(span: Span) -> Self {
441        let mut values = ThinVec::with_capacity(1);
442        values.push(DocCfgHideShowValue { span, value: None });
443        Self::List(values)
444    }
445
446    pub fn push_none(&mut self, span: Span) {
447        if let Self::List(values) = self
448            && !values.iter().any(|v| v.value.is_none())
449        {
450            values.push(DocCfgHideShowValue { span, value: None });
451        }
452    }
453
454    pub fn merge_with(&mut self, other: &Self) {
455        match (self, other) {
456            (Self::Any(_), Self::Any(_) | Self::List(_)) => {
457                // Nothing to do.
458            }
459            (s, Self::Any(span)) => {
460                // We "upgrade" the list values to "all".
461                *s = Self::Any(*span);
462            }
463            (Self::List(values), Self::List(other_values)) => {
464                // Having duplicates is not an issue, we simply ignore them. Would be more
465                // convenient to have a `set` type though. T_T
466                for other in other_values {
467                    if !values.iter().any(|value| value.value == other.value) {
468                        values.push(*other);
469                    }
470                }
471            }
472        }
473    }
474}
475
476#[derive(#[automatically_derived]impl ::core::clone::Clone for CfgHideShow {
    #[inline]
    fn clone(&self) -> Self {
        CfgHideShow {
            kind: ::core::clone::Clone::clone(&self.kind),
            values: ::core::clone::Clone::clone(&self.values),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for CfgHideShow {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f,
            "CfgHideShow kind values", &self.kind, &&self.values)
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for CfgHideShow
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    CfgHideShow { kind: ref __binding_0, values: ref __binding_1
                        } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for CfgHideShow {
            fn encode(&self, __encoder: &mut __E) {
                let CfgHideShow {
                        kind: ref __binding_0, values: ref __binding_1 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for CfgHideShow {
            fn decode(__decoder: &mut __D) -> Self {
                CfgHideShow {
                    kind: ::rustc_serialize::Decodable::decode(__decoder),
                    values: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for CfgHideShow {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { kind, values } = self;
                __p.word("CfgHideShow");
                if true && !kind.should_render() && !values.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if kind.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("kind");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                kind.print_attribute(__p);
                if values.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("values");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                values.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
477pub struct CfgHideShow {
478    pub kind: HideOrShow,
479    pub values: FxIndexMap<Symbol, DocCfgHideShow>,
480}
481
482#[derive(#[automatically_derived]impl ::core::clone::Clone for DocAttribute {
    #[inline]
    fn clone(&self) -> Self {
        DocAttribute {
            first_span: ::core::clone::Clone::clone(&self.first_span),
            aliases: ::core::clone::Clone::clone(&self.aliases),
            hidden: ::core::clone::Clone::clone(&self.hidden),
            inline: ::core::clone::Clone::clone(&self.inline),
            cfg: ::core::clone::Clone::clone(&self.cfg),
            auto_cfg: ::core::clone::Clone::clone(&self.auto_cfg),
            auto_cfg_change: ::core::clone::Clone::clone(&self.auto_cfg_change),
            fake_variadic: ::core::clone::Clone::clone(&self.fake_variadic),
            keyword: ::core::clone::Clone::clone(&self.keyword),
            attribute: ::core::clone::Clone::clone(&self.attribute),
            masked: ::core::clone::Clone::clone(&self.masked),
            notable_trait: ::core::clone::Clone::clone(&self.notable_trait),
            search_unbox: ::core::clone::Clone::clone(&self.search_unbox),
            html_favicon_url: ::core::clone::Clone::clone(&self.html_favicon_url),
            html_logo_url: ::core::clone::Clone::clone(&self.html_logo_url),
            html_playground_url: ::core::clone::Clone::clone(&self.html_playground_url),
            html_root_url: ::core::clone::Clone::clone(&self.html_root_url),
            html_no_source: ::core::clone::Clone::clone(&self.html_no_source),
            issue_tracker_base_url: ::core::clone::Clone::clone(&self.issue_tracker_base_url),
            rust_logo: ::core::clone::Clone::clone(&self.rust_logo),
            test_attrs: ::core::clone::Clone::clone(&self.test_attrs),
            no_crate_inject: ::core::clone::Clone::clone(&self.no_crate_inject),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocAttribute {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        let names: &'static _ =
            "DocAttribute first_span aliases hidden inline cfg auto_cfg auto_cfg_change fake_variadic keyword attribute masked notable_trait search_unbox html_favicon_url html_logo_url html_playground_url html_root_url html_no_source issue_tracker_base_url rust_logo test_attrs no_crate_inject";
        let values: &[&dyn ::core::fmt::Debug] =
            &[&self.first_span, &self.aliases, &self.hidden, &self.inline,
                        &self.cfg, &self.auto_cfg, &self.auto_cfg_change,
                        &self.fake_variadic, &self.keyword, &self.attribute,
                        &self.masked, &self.notable_trait, &self.search_unbox,
                        &self.html_favicon_url, &self.html_logo_url,
                        &self.html_playground_url, &self.html_root_url,
                        &self.html_no_source, &self.issue_tracker_base_url,
                        &self.rust_logo, &self.test_attrs, &&self.no_crate_inject];
        ::core::fmt::Formatter::debug_struct_fields_finish(f, names, values)
    }
}Debug, #[automatically_derived]impl ::core::default::Default for DocAttribute {
    #[inline]
    fn default() -> Self {
        DocAttribute {
            first_span: ::core::default::Default::default(),
            aliases: ::core::default::Default::default(),
            hidden: ::core::default::Default::default(),
            inline: ::core::default::Default::default(),
            cfg: ::core::default::Default::default(),
            auto_cfg: ::core::default::Default::default(),
            auto_cfg_change: ::core::default::Default::default(),
            fake_variadic: ::core::default::Default::default(),
            keyword: ::core::default::Default::default(),
            attribute: ::core::default::Default::default(),
            masked: ::core::default::Default::default(),
            notable_trait: ::core::default::Default::default(),
            search_unbox: ::core::default::Default::default(),
            html_favicon_url: ::core::default::Default::default(),
            html_logo_url: ::core::default::Default::default(),
            html_playground_url: ::core::default::Default::default(),
            html_root_url: ::core::default::Default::default(),
            html_no_source: ::core::default::Default::default(),
            issue_tracker_base_url: ::core::default::Default::default(),
            rust_logo: ::core::default::Default::default(),
            test_attrs: ::core::default::Default::default(),
            no_crate_inject: ::core::default::Default::default(),
        }
    }
}Default, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for DocAttribute
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    DocAttribute {
                        first_span: ref __binding_0,
                        aliases: ref __binding_1,
                        hidden: ref __binding_2,
                        inline: ref __binding_3,
                        cfg: ref __binding_4,
                        auto_cfg: ref __binding_5,
                        auto_cfg_change: ref __binding_6,
                        fake_variadic: ref __binding_7,
                        keyword: ref __binding_8,
                        attribute: ref __binding_9,
                        masked: ref __binding_10,
                        notable_trait: ref __binding_11,
                        search_unbox: ref __binding_12,
                        html_favicon_url: ref __binding_13,
                        html_logo_url: ref __binding_14,
                        html_playground_url: ref __binding_15,
                        html_root_url: ref __binding_16,
                        html_no_source: ref __binding_17,
                        issue_tracker_base_url: ref __binding_18,
                        rust_logo: ref __binding_19,
                        test_attrs: ref __binding_20,
                        no_crate_inject: ref __binding_21 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                        { __binding_4.stable_hash(__hcx, __hasher); }
                        { __binding_5.stable_hash(__hcx, __hasher); }
                        { __binding_6.stable_hash(__hcx, __hasher); }
                        { __binding_7.stable_hash(__hcx, __hasher); }
                        { __binding_8.stable_hash(__hcx, __hasher); }
                        { __binding_9.stable_hash(__hcx, __hasher); }
                        { __binding_10.stable_hash(__hcx, __hasher); }
                        { __binding_11.stable_hash(__hcx, __hasher); }
                        { __binding_12.stable_hash(__hcx, __hasher); }
                        { __binding_13.stable_hash(__hcx, __hasher); }
                        { __binding_14.stable_hash(__hcx, __hasher); }
                        { __binding_15.stable_hash(__hcx, __hasher); }
                        { __binding_16.stable_hash(__hcx, __hasher); }
                        { __binding_17.stable_hash(__hcx, __hasher); }
                        { __binding_18.stable_hash(__hcx, __hasher); }
                        { __binding_19.stable_hash(__hcx, __hasher); }
                        { __binding_20.stable_hash(__hcx, __hasher); }
                        { __binding_21.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for DocAttribute {
            fn decode(__decoder: &mut __D) -> Self {
                DocAttribute {
                    first_span: ::rustc_serialize::Decodable::decode(__decoder),
                    aliases: ::rustc_serialize::Decodable::decode(__decoder),
                    hidden: ::rustc_serialize::Decodable::decode(__decoder),
                    inline: ::rustc_serialize::Decodable::decode(__decoder),
                    cfg: ::rustc_serialize::Decodable::decode(__decoder),
                    auto_cfg: ::rustc_serialize::Decodable::decode(__decoder),
                    auto_cfg_change: ::rustc_serialize::Decodable::decode(__decoder),
                    fake_variadic: ::rustc_serialize::Decodable::decode(__decoder),
                    keyword: ::rustc_serialize::Decodable::decode(__decoder),
                    attribute: ::rustc_serialize::Decodable::decode(__decoder),
                    masked: ::rustc_serialize::Decodable::decode(__decoder),
                    notable_trait: ::rustc_serialize::Decodable::decode(__decoder),
                    search_unbox: ::rustc_serialize::Decodable::decode(__decoder),
                    html_favicon_url: ::rustc_serialize::Decodable::decode(__decoder),
                    html_logo_url: ::rustc_serialize::Decodable::decode(__decoder),
                    html_playground_url: ::rustc_serialize::Decodable::decode(__decoder),
                    html_root_url: ::rustc_serialize::Decodable::decode(__decoder),
                    html_no_source: ::rustc_serialize::Decodable::decode(__decoder),
                    issue_tracker_base_url: ::rustc_serialize::Decodable::decode(__decoder),
                    rust_logo: ::rustc_serialize::Decodable::decode(__decoder),
                    test_attrs: ::rustc_serialize::Decodable::decode(__decoder),
                    no_crate_inject: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for DocAttribute {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self {
                        first_span,
                        aliases,
                        hidden,
                        inline,
                        cfg,
                        auto_cfg,
                        auto_cfg_change,
                        fake_variadic,
                        keyword,
                        attribute,
                        masked,
                        notable_trait,
                        search_unbox,
                        html_favicon_url,
                        html_logo_url,
                        html_playground_url,
                        html_root_url,
                        html_no_source,
                        issue_tracker_base_url,
                        rust_logo,
                        test_attrs,
                        no_crate_inject } = self;
                __p.word("DocAttribute");
                if true && !first_span.should_render() &&
                                                                                                        !aliases.should_render() && !hidden.should_render() &&
                                                                                                !inline.should_render() && !cfg.should_render() &&
                                                                                        !auto_cfg.should_render() &&
                                                                                    !auto_cfg_change.should_render() &&
                                                                                !fake_variadic.should_render() && !keyword.should_render()
                                                                        && !attribute.should_render() && !masked.should_render() &&
                                                                !notable_trait.should_render() &&
                                                            !search_unbox.should_render() &&
                                                        !html_favicon_url.should_render() &&
                                                    !html_logo_url.should_render() &&
                                                !html_playground_url.should_render() &&
                                            !html_root_url.should_render() &&
                                        !html_no_source.should_render() &&
                                    !issue_tracker_base_url.should_render() &&
                                !rust_logo.should_render() && !test_attrs.should_render() &&
                        !no_crate_inject.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if first_span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("first_span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                first_span.print_attribute(__p);
                if aliases.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("aliases");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                aliases.print_attribute(__p);
                if hidden.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("hidden");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                hidden.print_attribute(__p);
                if inline.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("inline");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                inline.print_attribute(__p);
                if cfg.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("cfg");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                cfg.print_attribute(__p);
                if auto_cfg.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("auto_cfg");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                auto_cfg.print_attribute(__p);
                if auto_cfg_change.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("auto_cfg_change");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                auto_cfg_change.print_attribute(__p);
                if fake_variadic.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("fake_variadic");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                fake_variadic.print_attribute(__p);
                if keyword.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("keyword");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                keyword.print_attribute(__p);
                if attribute.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("attribute");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                attribute.print_attribute(__p);
                if masked.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("masked");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                masked.print_attribute(__p);
                if notable_trait.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("notable_trait");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                notable_trait.print_attribute(__p);
                if search_unbox.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("search_unbox");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                search_unbox.print_attribute(__p);
                if html_favicon_url.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("html_favicon_url");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                html_favicon_url.print_attribute(__p);
                if html_logo_url.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("html_logo_url");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                html_logo_url.print_attribute(__p);
                if html_playground_url.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("html_playground_url");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                html_playground_url.print_attribute(__p);
                if html_root_url.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("html_root_url");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                html_root_url.print_attribute(__p);
                if html_no_source.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("html_no_source");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                html_no_source.print_attribute(__p);
                if issue_tracker_base_url.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("issue_tracker_base_url");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                issue_tracker_base_url.print_attribute(__p);
                if rust_logo.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("rust_logo");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                rust_logo.print_attribute(__p);
                if test_attrs.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("test_attrs");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                test_attrs.print_attribute(__p);
                if no_crate_inject.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("no_crate_inject");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                no_crate_inject.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
483pub struct DocAttribute {
484    pub first_span: Span,
485
486    pub aliases: FxIndexMap<Symbol, Span>,
487    pub hidden: Option<Span>,
488    pub inline: Option<(DocInline, Span)>,
489
490    // unstable
491    pub cfg: ThinVec<CfgEntry>,
492    pub auto_cfg: ThinVec<(CfgHideShow, Span)>,
493    /// This is for `#[doc(auto_cfg = false|true)]`/`#[doc(auto_cfg)]`.
494    pub auto_cfg_change: ThinVec<(bool, Span)>,
495
496    // builtin
497    pub fake_variadic: Option<Span>,
498    pub keyword: Option<(Symbol, Span)>,
499    pub attribute: Option<(Symbol, Span)>,
500    pub masked: Option<Span>,
501    pub notable_trait: Option<(Option<(NotableTraitColor, Span)>, Span)>,
502    pub search_unbox: Option<Span>,
503
504    // valid on crate
505    pub html_favicon_url: Option<(Symbol, Span)>,
506    pub html_logo_url: Option<(Symbol, Span)>,
507    pub html_playground_url: Option<(Symbol, Span)>,
508    pub html_root_url: Option<(Symbol, Span)>,
509    pub html_no_source: Option<Span>,
510    pub issue_tracker_base_url: Option<(Symbol, Span)>,
511    pub rust_logo: Option<Span>,
512
513    // #[doc(test(...))]
514    pub test_attrs: ThinVec<Span>,
515    pub no_crate_inject: Option<Span>,
516}
517
518#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for NotableTraitColor {
}
#[automatically_derived]impl ::core::clone::Clone for NotableTraitColor {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for NotableTraitColor { }Copy, #[automatically_derived]impl ::core::fmt::Debug for NotableTraitColor {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "Grey Red Green Yellow Blue Magenta Cyan Transparent",
            match self {
                NotableTraitColor::Grey => 0usize,
                NotableTraitColor::Red => 5usize,
                NotableTraitColor::Green => 9usize,
                NotableTraitColor::Yellow => 15usize,
                NotableTraitColor::Blue => 22usize,
                NotableTraitColor::Magenta => 27usize,
                NotableTraitColor::Cyan => 35usize,
                NotableTraitColor::Transparent => 40usize,
            })
    }
}Debug, #[automatically_derived]impl ::core::cmp::Eq for NotableTraitColor { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    NotableTraitColor {
}
#[automatically_derived]impl ::core::cmp::PartialEq for NotableTraitColor {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq)]
519#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            NotableTraitColor {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    NotableTraitColor::Grey => 0u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Red => 1u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Green =>
                        2u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Yellow =>
                        3u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Blue => 4u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Magenta =>
                        5u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Cyan => 6u8.stable_hash(__hcx, __hasher),
                    NotableTraitColor::Transparent =>
                        7u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    NotableTraitColor::Grey => {}
                    NotableTraitColor::Red => {}
                    NotableTraitColor::Green => {}
                    NotableTraitColor::Yellow => {}
                    NotableTraitColor::Blue => {}
                    NotableTraitColor::Magenta => {}
                    NotableTraitColor::Cyan => {}
                    NotableTraitColor::Transparent => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for NotableTraitColor {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        NotableTraitColor::Grey => { 0usize }
                        NotableTraitColor::Red => { 1usize }
                        NotableTraitColor::Green => { 2usize }
                        NotableTraitColor::Yellow => { 3usize }
                        NotableTraitColor::Blue => { 4usize }
                        NotableTraitColor::Magenta => { 5usize }
                        NotableTraitColor::Cyan => { 6usize }
                        NotableTraitColor::Transparent => { 7usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for NotableTraitColor {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { NotableTraitColor::Grey }
                    1usize => { NotableTraitColor::Red }
                    2usize => { NotableTraitColor::Green }
                    3usize => { NotableTraitColor::Yellow }
                    4usize => { NotableTraitColor::Blue }
                    5usize => { NotableTraitColor::Magenta }
                    6usize => { NotableTraitColor::Cyan }
                    7usize => { NotableTraitColor::Transparent }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `NotableTraitColor`, expected 0..8, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for NotableTraitColor {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Grey => { __p.word("Grey") }
                    Self::Red => { __p.word("Red") }
                    Self::Green => { __p.word("Green") }
                    Self::Yellow => { __p.word("Yellow") }
                    Self::Blue => { __p.word("Blue") }
                    Self::Magenta => { __p.word("Magenta") }
                    Self::Cyan => { __p.word("Cyan") }
                    Self::Transparent => { __p.word("Transparent") }
                }
            }
        }
    };PrintAttribute)]
520pub enum NotableTraitColor {
521    Grey,
522    Red,
523    Green,
524    Yellow,
525    Blue,
526    Magenta,
527    Cyan,
528    Transparent,
529}
530
531impl From<NotableTraitColor> for &'static str {
532    fn from(color: NotableTraitColor) -> &'static str {
533        use NotableTraitColor::*;
534        match color {
535            Grey => "grey",
536            Red => "red",
537            Green => "green",
538            Yellow => "yellow",
539            Blue => "blue",
540            Magenta => "magenta",
541            Cyan => "cyan",
542            Transparent => "transparent",
543        }
544    }
545}
546
547impl std::fmt::Display for NotableTraitColor {
548    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
549        f.write_str((*self).into())
550    }
551}
552
553impl<E: rustc_span::SpanEncoder> rustc_serialize::Encodable<E> for DocAttribute {
554    fn encode(&self, encoder: &mut E) {
555        let DocAttribute {
556            first_span,
557            aliases,
558            hidden,
559            inline,
560            cfg,
561            auto_cfg,
562            auto_cfg_change,
563            fake_variadic,
564            keyword,
565            attribute,
566            masked,
567            notable_trait,
568            search_unbox,
569            html_favicon_url,
570            html_logo_url,
571            html_playground_url,
572            html_root_url,
573            html_no_source,
574            issue_tracker_base_url,
575            rust_logo,
576            test_attrs,
577            no_crate_inject,
578        } = self;
579        rustc_serialize::Encodable::<E>::encode(first_span, encoder);
580        rustc_serialize::Encodable::<E>::encode(aliases, encoder);
581        rustc_serialize::Encodable::<E>::encode(hidden, encoder);
582
583        // FIXME: The `doc(inline)` attribute is never encoded, but is it actually the right thing
584        // to do? I suspect the condition was broken, should maybe instead not encode anything if we
585        // have `doc(no_inline)`.
586        let inline = inline.filter(|(i, _)| *i != DocInline::Inline);
587        rustc_serialize::Encodable::<E>::encode(&inline, encoder);
588
589        rustc_serialize::Encodable::<E>::encode(cfg, encoder);
590        rustc_serialize::Encodable::<E>::encode(auto_cfg, encoder);
591        rustc_serialize::Encodable::<E>::encode(auto_cfg_change, encoder);
592        rustc_serialize::Encodable::<E>::encode(fake_variadic, encoder);
593        rustc_serialize::Encodable::<E>::encode(keyword, encoder);
594        rustc_serialize::Encodable::<E>::encode(attribute, encoder);
595        rustc_serialize::Encodable::<E>::encode(masked, encoder);
596        rustc_serialize::Encodable::<E>::encode(notable_trait, encoder);
597        rustc_serialize::Encodable::<E>::encode(search_unbox, encoder);
598        rustc_serialize::Encodable::<E>::encode(html_favicon_url, encoder);
599        rustc_serialize::Encodable::<E>::encode(html_logo_url, encoder);
600        rustc_serialize::Encodable::<E>::encode(html_playground_url, encoder);
601        rustc_serialize::Encodable::<E>::encode(html_root_url, encoder);
602        rustc_serialize::Encodable::<E>::encode(html_no_source, encoder);
603        rustc_serialize::Encodable::<E>::encode(issue_tracker_base_url, encoder);
604        rustc_serialize::Encodable::<E>::encode(rust_logo, encoder);
605        rustc_serialize::Encodable::<E>::encode(test_attrs, encoder);
606        rustc_serialize::Encodable::<E>::encode(no_crate_inject, encoder);
607    }
608}
609
610#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcShowSpansKind {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::Expr => RustcShowSpansKind::Expr,
            Self::Ty => RustcShowSpansKind::Ty,
            Self::Path => RustcShowSpansKind::Path,
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcShowSpansKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                RustcShowSpansKind::Expr => "Expr",
                RustcShowSpansKind::Ty => "Ty",
                RustcShowSpansKind::Path => "Path",
            })
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcShowSpansKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcShowSpansKind::Expr =>
                        0u8.stable_hash(__hcx, __hasher),
                    RustcShowSpansKind::Ty => 1u8.stable_hash(__hcx, __hasher),
                    RustcShowSpansKind::Path =>
                        2u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RustcShowSpansKind::Expr => {}
                    RustcShowSpansKind::Ty => {}
                    RustcShowSpansKind::Path => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcShowSpansKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        RustcShowSpansKind::Expr => { 0usize }
                        RustcShowSpansKind::Ty => { 1usize }
                        RustcShowSpansKind::Path => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcShowSpansKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { RustcShowSpansKind::Expr }
                    1usize => { RustcShowSpansKind::Ty }
                    2usize => { RustcShowSpansKind::Path }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcShowSpansKind`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcShowSpansKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Expr => { __p.word("Expr") }
                    Self::Ty => { __p.word("Ty") }
                    Self::Path => { __p.word("Path") }
                }
            }
        }
    };PrintAttribute)]
611pub enum RustcShowSpansKind {
612    Expr,
613    Ty,
614    Path,
615}
616
617#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcDumpLayoutKind {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::Align => RustcDumpLayoutKind::Align,
            Self::BackendRepr => RustcDumpLayoutKind::BackendRepr,
            Self::Debug => RustcDumpLayoutKind::Debug,
            Self::HomogenousAggregate =>
                RustcDumpLayoutKind::HomogenousAggregate,
            Self::LargestNiche => RustcDumpLayoutKind::LargestNiche,
            Self::Size => RustcDumpLayoutKind::Size,
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcDumpLayoutKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "Align BackendRepr Debug HomogenousAggregate LargestNiche Size",
            match self {
                RustcDumpLayoutKind::Align => 0usize,
                RustcDumpLayoutKind::BackendRepr => 6usize,
                RustcDumpLayoutKind::Debug => 18usize,
                RustcDumpLayoutKind::HomogenousAggregate => 24usize,
                RustcDumpLayoutKind::LargestNiche => 44usize,
                RustcDumpLayoutKind::Size => 57usize,
            })
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcDumpLayoutKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcDumpLayoutKind::Align =>
                        0u8.stable_hash(__hcx, __hasher),
                    RustcDumpLayoutKind::BackendRepr =>
                        1u8.stable_hash(__hcx, __hasher),
                    RustcDumpLayoutKind::Debug =>
                        2u8.stable_hash(__hcx, __hasher),
                    RustcDumpLayoutKind::HomogenousAggregate =>
                        3u8.stable_hash(__hcx, __hasher),
                    RustcDumpLayoutKind::LargestNiche =>
                        4u8.stable_hash(__hcx, __hasher),
                    RustcDumpLayoutKind::Size =>
                        5u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RustcDumpLayoutKind::Align => {}
                    RustcDumpLayoutKind::BackendRepr => {}
                    RustcDumpLayoutKind::Debug => {}
                    RustcDumpLayoutKind::HomogenousAggregate => {}
                    RustcDumpLayoutKind::LargestNiche => {}
                    RustcDumpLayoutKind::Size => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcDumpLayoutKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        RustcDumpLayoutKind::Align => { 0usize }
                        RustcDumpLayoutKind::BackendRepr => { 1usize }
                        RustcDumpLayoutKind::Debug => { 2usize }
                        RustcDumpLayoutKind::HomogenousAggregate => { 3usize }
                        RustcDumpLayoutKind::LargestNiche => { 4usize }
                        RustcDumpLayoutKind::Size => { 5usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcDumpLayoutKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { RustcDumpLayoutKind::Align }
                    1usize => { RustcDumpLayoutKind::BackendRepr }
                    2usize => { RustcDumpLayoutKind::Debug }
                    3usize => { RustcDumpLayoutKind::HomogenousAggregate }
                    4usize => { RustcDumpLayoutKind::LargestNiche }
                    5usize => { RustcDumpLayoutKind::Size }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcDumpLayoutKind`, expected 0..6, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcDumpLayoutKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Align => { __p.word("Align") }
                    Self::BackendRepr => { __p.word("BackendRepr") }
                    Self::Debug => { __p.word("Debug") }
                    Self::HomogenousAggregate => {
                        __p.word("HomogenousAggregate")
                    }
                    Self::LargestNiche => { __p.word("LargestNiche") }
                    Self::Size => { __p.word("Size") }
                }
            }
        }
    };PrintAttribute)]
618pub enum RustcDumpLayoutKind {
619    Align,
620    BackendRepr,
621    Debug,
622    HomogenousAggregate,
623    LargestNiche,
624    Size,
625}
626
627#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcMirKind {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::PrettyLiveLocals => RustcMirKind::PrettyLiveLocals,
            Self::PrettyPreciseLiveness =>
                RustcMirKind::PrettyPreciseLiveness,
            Self::PrettyTransitiveLiveLocals =>
                RustcMirKind::PrettyTransitiveLiveLocals,
            Self::PeekMaybeInit => RustcMirKind::PeekMaybeInit,
            Self::PeekMaybeUninit => RustcMirKind::PeekMaybeUninit,
            Self::PeekLiveness => RustcMirKind::PeekLiveness,
            Self::StopAfterDataflow => RustcMirKind::StopAfterDataflow,
            Self::BorrowckGraphvizPostflow { path: __self_0 } =>
                RustcMirKind::BorrowckGraphvizPostflow {
                    path: ::core::clone::Clone::clone(__self_0),
                },
            Self::BorrowckGraphvizFormat { format: __self_0 } =>
                RustcMirKind::BorrowckGraphvizFormat {
                    format: ::core::clone::Clone::clone(__self_0),
                },
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcMirKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::PrettyLiveLocals =>
                ::core::fmt::Formatter::write_str(f, "PrettyLiveLocals"),
            Self::PrettyPreciseLiveness =>
                ::core::fmt::Formatter::write_str(f, "PrettyPreciseLiveness"),
            Self::PrettyTransitiveLiveLocals =>
                ::core::fmt::Formatter::write_str(f,
                    "PrettyTransitiveLiveLocals"),
            Self::PeekMaybeInit =>
                ::core::fmt::Formatter::write_str(f, "PeekMaybeInit"),
            Self::PeekMaybeUninit =>
                ::core::fmt::Formatter::write_str(f, "PeekMaybeUninit"),
            Self::PeekLiveness =>
                ::core::fmt::Formatter::write_str(f, "PeekLiveness"),
            Self::StopAfterDataflow =>
                ::core::fmt::Formatter::write_str(f, "StopAfterDataflow"),
            Self::BorrowckGraphvizPostflow { path: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "BorrowckGraphvizPostflow path", &__self_0),
            Self::BorrowckGraphvizFormat { format: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "BorrowckGraphvizFormat format", &__self_0),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for RustcMirKind
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcMirKind::PrettyLiveLocals =>
                        0u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::PrettyPreciseLiveness =>
                        1u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::PrettyTransitiveLiveLocals =>
                        2u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::PeekMaybeInit =>
                        3u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::PeekMaybeUninit =>
                        4u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::PeekLiveness =>
                        5u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::StopAfterDataflow =>
                        6u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::BorrowckGraphvizPostflow {
                        path: ref __binding_0 } => 7u8.stable_hash(__hcx, __hasher),
                    RustcMirKind::BorrowckGraphvizFormat {
                        format: ref __binding_0 } =>
                        8u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RustcMirKind::PrettyLiveLocals => {}
                    RustcMirKind::PrettyPreciseLiveness => {}
                    RustcMirKind::PrettyTransitiveLiveLocals => {}
                    RustcMirKind::PeekMaybeInit => {}
                    RustcMirKind::PeekMaybeUninit => {}
                    RustcMirKind::PeekLiveness => {}
                    RustcMirKind::StopAfterDataflow => {}
                    RustcMirKind::BorrowckGraphvizPostflow {
                        path: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    RustcMirKind::BorrowckGraphvizFormat {
                        format: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcMirKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        RustcMirKind::PrettyLiveLocals => { 0usize }
                        RustcMirKind::PrettyPreciseLiveness => { 1usize }
                        RustcMirKind::PrettyTransitiveLiveLocals => { 2usize }
                        RustcMirKind::PeekMaybeInit => { 3usize }
                        RustcMirKind::PeekMaybeUninit => { 4usize }
                        RustcMirKind::PeekLiveness => { 5usize }
                        RustcMirKind::StopAfterDataflow => { 6usize }
                        RustcMirKind::BorrowckGraphvizPostflow {
                            path: ref __binding_0 } => {
                            7usize
                        }
                        RustcMirKind::BorrowckGraphvizFormat {
                            format: ref __binding_0 } => {
                            8usize
                        }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    RustcMirKind::PrettyLiveLocals => {}
                    RustcMirKind::PrettyPreciseLiveness => {}
                    RustcMirKind::PrettyTransitiveLiveLocals => {}
                    RustcMirKind::PeekMaybeInit => {}
                    RustcMirKind::PeekMaybeUninit => {}
                    RustcMirKind::PeekLiveness => {}
                    RustcMirKind::StopAfterDataflow => {}
                    RustcMirKind::BorrowckGraphvizPostflow {
                        path: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    RustcMirKind::BorrowckGraphvizFormat {
                        format: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcMirKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { RustcMirKind::PrettyLiveLocals }
                    1usize => { RustcMirKind::PrettyPreciseLiveness }
                    2usize => { RustcMirKind::PrettyTransitiveLiveLocals }
                    3usize => { RustcMirKind::PeekMaybeInit }
                    4usize => { RustcMirKind::PeekMaybeUninit }
                    5usize => { RustcMirKind::PeekLiveness }
                    6usize => { RustcMirKind::StopAfterDataflow }
                    7usize => {
                        RustcMirKind::BorrowckGraphvizPostflow {
                            path: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    8usize => {
                        RustcMirKind::BorrowckGraphvizFormat {
                            format: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcMirKind`, expected 0..9, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcMirKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::PrettyLiveLocals => { __p.word("PrettyLiveLocals") }
                    Self::PrettyPreciseLiveness => {
                        __p.word("PrettyPreciseLiveness")
                    }
                    Self::PrettyTransitiveLiveLocals => {
                        __p.word("PrettyTransitiveLiveLocals")
                    }
                    Self::PeekMaybeInit => { __p.word("PeekMaybeInit") }
                    Self::PeekMaybeUninit => { __p.word("PeekMaybeUninit") }
                    Self::PeekLiveness => { __p.word("PeekLiveness") }
                    Self::StopAfterDataflow => { __p.word("StopAfterDataflow") }
                    Self::BorrowckGraphvizPostflow { path } => {
                        __p.word("BorrowckGraphvizPostflow");
                        if true && !path.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if path.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("path");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        path.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::BorrowckGraphvizFormat { format } => {
                        __p.word("BorrowckGraphvizFormat");
                        if true && !format.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if format.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("format");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        format.print_attribute(__p);
                        __p.word("}");
                    }
                }
            }
        }
    };PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RustcMirKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcMirKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::BorrowckGraphvizPostflow { path: __self_0 },
                    Self::BorrowckGraphvizPostflow { path: __arg1_0 }) =>
                    __self_0 == __arg1_0,
                (Self::BorrowckGraphvizFormat { format: __self_0 },
                    Self::BorrowckGraphvizFormat { format: __arg1_0 }) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcMirKind {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<PathBuf>;
        let _: ::core::cmp::AssertParamIsEq<BorrowckGraphvizFormatKind>;
    }
}Eq)]
628pub enum RustcMirKind {
629    PrettyLiveLocals,
630    PrettyPreciseLiveness,
631    PrettyTransitiveLiveLocals,
632    PeekMaybeInit,
633    PeekMaybeUninit,
634    PeekLiveness,
635    StopAfterDataflow,
636    BorrowckGraphvizPostflow { path: PathBuf },
637    BorrowckGraphvizFormat { format: BorrowckGraphvizFormatKind },
638}
639
640#[derive(#[automatically_derived]impl ::core::clone::Clone for
    BorrowckGraphvizFormatKind {
    #[inline]
    fn clone(&self) -> Self { BorrowckGraphvizFormatKind::TwoPhase }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for BorrowckGraphvizFormatKind
    {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f, "TwoPhase")
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            BorrowckGraphvizFormatKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    BorrowckGraphvizFormatKind::TwoPhase =>
                        0u8.stable_hash(__hcx, __hasher),
                }
                match *self { BorrowckGraphvizFormatKind::TwoPhase => {} }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for BorrowckGraphvizFormatKind {
            fn encode(&self, __encoder: &mut __E) {}
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for BorrowckGraphvizFormatKind {
            fn decode(__decoder: &mut __D) -> Self {
                BorrowckGraphvizFormatKind::TwoPhase
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for BorrowckGraphvizFormatKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self { Self::TwoPhase => { __p.word("TwoPhase") } }
            }
        }
    };PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    BorrowckGraphvizFormatKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for
    BorrowckGraphvizFormatKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool { true }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for BorrowckGraphvizFormatKind {
}Eq)]
641pub enum BorrowckGraphvizFormatKind {
642    TwoPhase,
643}
644
645#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanAttribute {
    #[inline]
    fn clone(&self) -> Self {
        RustcCleanAttribute {
            span: ::core::clone::Clone::clone(&self.span),
            cfg: ::core::clone::Clone::clone(&self.cfg),
            except: ::core::clone::Clone::clone(&self.except),
            loaded_from_disk: ::core::clone::Clone::clone(&self.loaded_from_disk),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcCleanAttribute {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field4_finish(f,
            "RustcCleanAttribute span cfg except loaded_from_disk",
            &self.span, &self.cfg, &self.except, &&self.loaded_from_disk)
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RustcCleanAttribute {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcCleanAttribute {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.span == other.span && self.cfg == other.cfg &&
                self.except == other.except &&
            self.loaded_from_disk == other.loaded_from_disk
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcCleanAttribute {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<Span>;
        let _: ::core::cmp::AssertParamIsEq<Symbol>;
        let _: ::core::cmp::AssertParamIsEq<Option<RustcCleanQueries>>;
        let _: ::core::cmp::AssertParamIsEq<Option<RustcCleanQueries>>;
    }
}Eq)]
646#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcCleanAttribute {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcCleanAttribute {
                        span: ref __binding_0,
                        cfg: ref __binding_1,
                        except: ref __binding_2,
                        loaded_from_disk: ref __binding_3 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcCleanAttribute {
            fn encode(&self, __encoder: &mut __E) {
                let RustcCleanAttribute {
                        span: ref __binding_0,
                        cfg: ref __binding_1,
                        except: ref __binding_2,
                        loaded_from_disk: ref __binding_3 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcCleanAttribute {
            fn decode(__decoder: &mut __D) -> Self {
                RustcCleanAttribute {
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                    cfg: ::rustc_serialize::Decodable::decode(__decoder),
                    except: ::rustc_serialize::Decodable::decode(__decoder),
                    loaded_from_disk: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcCleanAttribute {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { span, cfg, except, loaded_from_disk } = self;
                __p.word("RustcCleanAttribute");
                if true && !span.should_render() && !cfg.should_render() &&
                            !except.should_render() && !loaded_from_disk.should_render()
                    {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                span.print_attribute(__p);
                if cfg.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("cfg");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                cfg.print_attribute(__p);
                if except.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("except");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                except.print_attribute(__p);
                if loaded_from_disk.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("loaded_from_disk");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                loaded_from_disk.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
647pub struct RustcCleanAttribute {
648    pub span: Span,
649    pub cfg: Symbol,
650    pub except: Option<RustcCleanQueries>,
651    pub loaded_from_disk: Option<RustcCleanQueries>,
652}
653
654/// Represents the `except=` or `loaded_from_disk=` argument of `#[rustc_clean]`
655#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanQueries {
    #[inline]
    fn clone(&self) -> Self {
        RustcCleanQueries {
            entries: ::core::clone::Clone::clone(&self.entries),
            span: ::core::clone::Clone::clone(&self.span),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcCleanQueries {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f,
            "RustcCleanQueries entries span", &self.entries, &&self.span)
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RustcCleanQueries {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcCleanQueries {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.entries == other.entries && self.span == other.span
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcCleanQueries {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<ThinVec<Symbol>>;
        let _: ::core::cmp::AssertParamIsEq<Span>;
    }
}Eq)]
656#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcCleanQueries {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcCleanQueries {
                        entries: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcCleanQueries {
            fn encode(&self, __encoder: &mut __E) {
                let RustcCleanQueries {
                        entries: ref __binding_0, span: ref __binding_1 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcCleanQueries {
            fn decode(__decoder: &mut __D) -> Self {
                RustcCleanQueries {
                    entries: ::rustc_serialize::Decodable::decode(__decoder),
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcCleanQueries {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { entries, span } = self;
                __p.word("RustcCleanQueries");
                if true && !entries.should_render() && !span.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if entries.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("entries");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                entries.print_attribute(__p);
                if span.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("span");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                span.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
657pub struct RustcCleanQueries {
658    pub entries: ThinVec<Symbol>,
659    pub span: Span,
660}
661
662#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcAutodiff {
    #[inline]
    fn clone(&self) -> Self {
        RustcAutodiff {
            mode: ::core::clone::Clone::clone(&self.mode),
            width: ::core::clone::Clone::clone(&self.width),
            input_activity: ::core::clone::Clone::clone(&self.input_activity),
            ret_activity: ::core::clone::Clone::clone(&self.ret_activity),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcAutodiff {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field4_finish(f,
            "RustcAutodiff mode width input_activity ret_activity",
            &self.mode, &self.width, &self.input_activity,
            &&self.ret_activity)
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RustcAutodiff {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcAutodiff {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.width == other.width && self.mode == other.mode &&
                self.input_activity == other.input_activity &&
            self.ret_activity == other.ret_activity
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcAutodiff {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<DiffMode>;
        let _: ::core::cmp::AssertParamIsEq<u32>;
        let _: ::core::cmp::AssertParamIsEq<ThinVec<DiffActivity>>;
        let _: ::core::cmp::AssertParamIsEq<DiffActivity>;
    }
}Eq)]
663#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcAutodiff {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcAutodiff {
                        mode: ref __binding_0,
                        width: ref __binding_1,
                        input_activity: ref __binding_2,
                        ret_activity: ref __binding_3 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcAutodiff {
            fn encode(&self, __encoder: &mut __E) {
                let RustcAutodiff {
                        mode: ref __binding_0,
                        width: ref __binding_1,
                        input_activity: ref __binding_2,
                        ret_activity: ref __binding_3 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcAutodiff {
            fn decode(__decoder: &mut __D) -> Self {
                RustcAutodiff {
                    mode: ::rustc_serialize::Decodable::decode(__decoder),
                    width: ::rustc_serialize::Decodable::decode(__decoder),
                    input_activity: ::rustc_serialize::Decodable::decode(__decoder),
                    ret_activity: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcAutodiff {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { mode, width, input_activity, ret_activity } = self;
                __p.word("RustcAutodiff");
                if true && !mode.should_render() && !width.should_render() &&
                            !input_activity.should_render() &&
                        !ret_activity.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if mode.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("mode");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                mode.print_attribute(__p);
                if width.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("width");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                width.print_attribute(__p);
                if input_activity.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("input_activity");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                input_activity.print_attribute(__p);
                if ret_activity.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("ret_activity");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                ret_activity.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
664pub struct RustcAutodiff {
665    /// Conceptually either forward or reverse mode AD, as described in various autodiff papers and
666    /// e.g. in the [JAX
667    /// Documentation](https://jax.readthedocs.io/en/latest/_tutorials/advanced-autodiff.html#how-it-s-made-two-foundational-autodiff-functions).
668    pub mode: DiffMode,
669    /// A user-provided, batching width. If not given, we will default to 1 (no batching).
670    /// Calling a differentiated, non-batched function through a loop 100 times is equivalent to:
671    /// - Calling the function 50 times with a batch size of 2
672    /// - Calling the function 25 times with a batch size of 4,
673    /// etc. A batched function takes more (or longer) arguments, and might be able to benefit from
674    /// cache locality, better re-usal of primal values, and other optimizations.
675    /// We will (before LLVM's vectorizer runs) just generate most LLVM-IR instructions `width`
676    /// times, so this massively increases code size. As such, values like 1024 are unlikely to
677    /// work. We should consider limiting this to u8 or u16, but will leave it at u32 for
678    /// experiments for now and focus on documenting the implications of a large width.
679    pub width: u32,
680    pub input_activity: ThinVec<DiffActivity>,
681    pub ret_activity: DiffActivity,
682}
683
684impl RustcAutodiff {
685    pub fn has_primal_ret(&self) -> bool {
686        #[allow(non_exhaustive_omitted_patterns)] match self.ret_activity {
    DiffActivity::Active | DiffActivity::Dual => true,
    _ => false,
}matches!(self.ret_activity, DiffActivity::Active | DiffActivity::Dual)
687    }
688}
689
690impl RustcAutodiff {
691    pub fn has_ret_activity(&self) -> bool {
692        self.ret_activity != DiffActivity::None
693    }
694    pub fn has_active_only_ret(&self) -> bool {
695        self.ret_activity == DiffActivity::ActiveOnly
696    }
697
698    pub fn error() -> Self {
699        RustcAutodiff {
700            mode: DiffMode::Error,
701            width: 0,
702            ret_activity: DiffActivity::None,
703            input_activity: ThinVec::new(),
704        }
705    }
706
707    pub fn source() -> Self {
708        RustcAutodiff {
709            mode: DiffMode::Source,
710            width: 0,
711            ret_activity: DiffActivity::None,
712            input_activity: ThinVec::new(),
713        }
714    }
715
716    pub fn is_active(&self) -> bool {
717        self.mode != DiffMode::Error
718    }
719
720    pub fn is_source(&self) -> bool {
721        self.mode == DiffMode::Source
722    }
723    pub fn apply_autodiff(&self) -> bool {
724        !#[allow(non_exhaustive_omitted_patterns)] match self.mode {
    DiffMode::Error | DiffMode::Source => true,
    _ => false,
}matches!(self.mode, DiffMode::Error | DiffMode::Source)
725    }
726
727    pub fn into_item(
728        self,
729        source: String,
730        target: String,
731        inputs: Vec<TypeTree>,
732        output: TypeTree,
733    ) -> AutoDiffItem {
734        AutoDiffItem { source, target, inputs, output, attrs: self }
735    }
736}
737
738/// We generate one of these structs for each `#[autodiff(...)]` attribute.
739#[derive(#[automatically_derived]impl ::core::clone::Clone for AutoDiffItem {
    #[inline]
    fn clone(&self) -> Self {
        AutoDiffItem {
            source: ::core::clone::Clone::clone(&self.source),
            target: ::core::clone::Clone::clone(&self.target),
            attrs: ::core::clone::Clone::clone(&self.attrs),
            inputs: ::core::clone::Clone::clone(&self.inputs),
            output: ::core::clone::Clone::clone(&self.output),
        }
    }
}Clone, #[automatically_derived]impl ::core::cmp::Eq for AutoDiffItem {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<String>;
        let _: ::core::cmp::AssertParamIsEq<RustcAutodiff>;
        let _: ::core::cmp::AssertParamIsEq<Vec<TypeTree>>;
        let _: ::core::cmp::AssertParamIsEq<TypeTree>;
    }
}Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    AutoDiffItem {
}
#[automatically_derived]impl ::core::cmp::PartialEq for AutoDiffItem {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.source == other.source && self.target == other.target &&
                    self.attrs == other.attrs && self.inputs == other.inputs &&
            self.output == other.output
    }
}PartialEq, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for AutoDiffItem {
            fn encode(&self, __encoder: &mut __E) {
                let AutoDiffItem {
                        source: ref __binding_0,
                        target: ref __binding_1,
                        attrs: ref __binding_2,
                        inputs: ref __binding_3,
                        output: ref __binding_4 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_4,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for AutoDiffItem {
            fn decode(__decoder: &mut __D) -> Self {
                AutoDiffItem {
                    source: ::rustc_serialize::Decodable::decode(__decoder),
                    target: ::rustc_serialize::Decodable::decode(__decoder),
                    attrs: ::rustc_serialize::Decodable::decode(__decoder),
                    inputs: ::rustc_serialize::Decodable::decode(__decoder),
                    output: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, #[automatically_derived]impl ::core::fmt::Debug for AutoDiffItem {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field5_finish(f,
            "AutoDiffItem source target attrs inputs output", &self.source,
            &self.target, &self.attrs, &self.inputs, &&self.output)
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for AutoDiffItem
            {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    AutoDiffItem {
                        source: ref __binding_0,
                        target: ref __binding_1,
                        attrs: ref __binding_2,
                        inputs: ref __binding_3,
                        output: ref __binding_4 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                        { __binding_4.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash)]
740pub struct AutoDiffItem {
741    /// The name of the function getting differentiated
742    pub source: String,
743    /// The name of the function being generated
744    pub target: String,
745    pub attrs: RustcAutodiff,
746    pub inputs: Vec<TypeTree>,
747    pub output: TypeTree,
748}
749
750impl fmt::Display for AutoDiffItem {
751    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
752        f.write_fmt(format_args!("Differentiating {0} -> {1}", self.source,
        self.target))write!(f, "Differentiating {} -> {}", self.source, self.target)?;
753        f.write_fmt(format_args!(" with attributes: {0:?}", self.attrs))write!(f, " with attributes: {:?}", self.attrs)?;
754        f.write_fmt(format_args!(" with inputs: {0:?}", self.inputs))write!(f, " with inputs: {:?}", self.inputs)?;
755        f.write_fmt(format_args!(" with output: {0:?}", self.output))write!(f, " with output: {:?}", self.output)
756    }
757}
758
759#[derive(#[automatically_derived]impl ::core::marker::Copy for RustcAssertVarianceKind
    {
}Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for RustcAssertVarianceKind {
}
#[automatically_derived]impl ::core::clone::Clone for RustcAssertVarianceKind
    {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcAssertVarianceKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                RustcAssertVarianceKind::Covariant => "Covariant",
                RustcAssertVarianceKind::Invariant => "Invariant",
                RustcAssertVarianceKind::Contravariant => "Contravariant",
                RustcAssertVarianceKind::Bivariant => "Bivariant",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    RustcAssertVarianceKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for
    RustcAssertVarianceKind {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcAssertVarianceKind { }Eq)]
760#[derive(const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            RustcAssertVarianceKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    RustcAssertVarianceKind::Covariant =>
                        0u8.stable_hash(__hcx, __hasher),
                    RustcAssertVarianceKind::Invariant =>
                        1u8.stable_hash(__hcx, __hasher),
                    RustcAssertVarianceKind::Contravariant =>
                        2u8.stable_hash(__hcx, __hasher),
                    RustcAssertVarianceKind::Bivariant =>
                        3u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RustcAssertVarianceKind::Covariant => {}
                    RustcAssertVarianceKind::Invariant => {}
                    RustcAssertVarianceKind::Contravariant => {}
                    RustcAssertVarianceKind::Bivariant => {}
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for RustcAssertVarianceKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        RustcAssertVarianceKind::Covariant => { 0usize }
                        RustcAssertVarianceKind::Invariant => { 1usize }
                        RustcAssertVarianceKind::Contravariant => { 2usize }
                        RustcAssertVarianceKind::Bivariant => { 3usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for RustcAssertVarianceKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { RustcAssertVarianceKind::Covariant }
                    1usize => { RustcAssertVarianceKind::Invariant }
                    2usize => { RustcAssertVarianceKind::Contravariant }
                    3usize => { RustcAssertVarianceKind::Bivariant }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcAssertVarianceKind`, expected 0..4, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for RustcAssertVarianceKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::Covariant => { __p.word("Covariant") }
                    Self::Invariant => { __p.word("Invariant") }
                    Self::Contravariant => { __p.word("Contravariant") }
                    Self::Bivariant => { __p.word("Bivariant") }
                }
            }
        }
    };PrintAttribute)]
761pub enum RustcAssertVarianceKind {
762    Covariant,
763    Invariant,
764    Contravariant,
765    Bivariant,
766}
767
768#[derive(#[automatically_derived]impl ::core::clone::Clone for UnstableRemovedFeature {
    #[inline]
    fn clone(&self) -> Self {
        UnstableRemovedFeature {
            feature: ::core::clone::Clone::clone(&self.feature),
            reason: ::core::clone::Clone::clone(&self.reason),
            link: ::core::clone::Clone::clone(&self.link),
            since: ::core::clone::Clone::clone(&self.since),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for UnstableRemovedFeature {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field4_finish(f,
            "UnstableRemovedFeature feature reason link since", &self.feature,
            &self.reason, &self.link, &&self.since)
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            UnstableRemovedFeature {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    UnstableRemovedFeature {
                        feature: ref __binding_0,
                        reason: ref __binding_1,
                        link: ref __binding_2,
                        since: ref __binding_3 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for UnstableRemovedFeature {
            fn encode(&self, __encoder: &mut __E) {
                let UnstableRemovedFeature {
                        feature: ref __binding_0,
                        reason: ref __binding_1,
                        link: ref __binding_2,
                        since: ref __binding_3 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for UnstableRemovedFeature {
            fn decode(__decoder: &mut __D) -> Self {
                UnstableRemovedFeature {
                    feature: ::rustc_serialize::Decodable::decode(__decoder),
                    reason: ::rustc_serialize::Decodable::decode(__decoder),
                    link: ::rustc_serialize::Decodable::decode(__decoder),
                    since: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for UnstableRemovedFeature {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                let Self { feature, reason, link, since } = self;
                __p.word("UnstableRemovedFeature");
                if true && !feature.should_render() && !reason.should_render()
                            && !link.should_render() && !since.should_render() {
                    return;
                }
                __p.nbsp();
                __p.word("{");
                let mut __printed_anything = false;
                if feature.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("feature");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                feature.print_attribute(__p);
                if reason.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("reason");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                reason.print_attribute(__p);
                if link.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("link");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                link.print_attribute(__p);
                if since.should_render() {
                    if __printed_anything { __p.word_space(","); }
                    __p.word("since");
                    __p.word(":");
                    __p.nbsp();
                    __printed_anything = true;
                }
                since.print_attribute(__p);
                __p.word("}");
            }
        }
    };PrintAttribute)]
769pub struct UnstableRemovedFeature {
770    pub feature: Symbol,
771    pub reason: Symbol,
772    pub link: Symbol,
773    pub since: RustcVersion,
774}
775
776/// Represents parsed *built-in* inert attributes.
777///
778/// ## Overview
779/// These attributes are markers that guide the compilation process and are never expanded into other code.
780/// They persist throughout the compilation phases, from AST to HIR and beyond.
781///
782/// ## Attribute Processing
783/// While attributes are initially parsed by [`rustc_parse`] into [`ast::Attribute`], they still contain raw token streams
784/// because different attributes have different internal structures. This enum represents the final,
785/// fully parsed form of these attributes, where each variant contains all the information and
786/// structure relevant for the specific attribute.
787///
788/// Some attributes can be applied multiple times to the same item, and they are "collapsed" into a single
789/// semantic attribute. For example:
790/// ```rust
791/// #[repr(C)]
792/// #[repr(packed)]
793/// struct S { }
794/// ```
795/// This is equivalent to `#[repr(C, packed)]` and results in a single [`AttributeKind::Repr`] containing
796/// both `C` and `packed` annotations. This collapsing happens during parsing and is reflected in the
797/// data structures defined in this enum.
798///
799/// ## Usage
800/// These parsed attributes are used throughout the compiler to:
801/// - Control code generation (e.g., `#[repr]`)
802/// - Mark API stability (`#[stable]`, `#[unstable]`)
803/// - Provide documentation (`#[doc]`)
804/// - Guide compiler behavior (e.g., `#[allow_internal_unstable]`)
805///
806/// ## Note on Attribute Organization
807/// Some attributes like `InlineAttr`, `OptimizeAttr`, and `InstructionSetAttr` are defined separately
808/// from this enum because they are used in specific compiler phases (like code generation) and don't
809/// need to persist throughout the entire compilation process. They are typically processed and
810/// converted into their final form earlier in the compilation pipeline.
811///
812/// For example:
813/// - `InlineAttr` is used during code generation to control function inlining
814/// - `OptimizeAttr` is used to control optimization levels
815/// - `InstructionSetAttr` is used for target-specific code generation
816///
817/// These attributes are handled by their respective compiler passes in the [`rustc_codegen_ssa`] crate
818/// and don't need to be preserved in the same way as the attributes in this enum.
819///
820/// For more details on attribute parsing, see the [`rustc_attr_parsing`] crate.
821///
822/// [`rustc_parse`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
823/// [`rustc_codegen_ssa`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/index.html
824/// [`rustc_attr_parsing`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_attr_parsing/index.html
825#[derive(#[automatically_derived]impl ::core::clone::Clone for AttributeKind {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::AllowInternalUnsafe(__self_0) =>
                AttributeKind::AllowInternalUnsafe(::core::clone::Clone::clone(__self_0)),
            Self::AllowInternalUnstable(__self_0, __self_1) =>
                AttributeKind::AllowInternalUnstable(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::AlwaysGca => AttributeKind::AlwaysGca,
            Self::AutomaticallyDerived => AttributeKind::AutomaticallyDerived,
            Self::CfgAttrTrace(__self_0) =>
                AttributeKind::CfgAttrTrace(::core::clone::Clone::clone(__self_0)),
            Self::CfgTrace(__self_0) =>
                AttributeKind::CfgTrace(::core::clone::Clone::clone(__self_0)),
            Self::CfiEncoding { encoding: __self_0 } =>
                AttributeKind::CfiEncoding {
                    encoding: ::core::clone::Clone::clone(__self_0),
                },
            Self::Cold => AttributeKind::Cold,
            Self::CollapseDebugInfo(__self_0) =>
                AttributeKind::CollapseDebugInfo(::core::clone::Clone::clone(__self_0)),
            Self::CompilerBuiltins => AttributeKind::CompilerBuiltins,
            Self::ConstContinue(__self_0) =>
                AttributeKind::ConstContinue(::core::clone::Clone::clone(__self_0)),
            Self::Coroutine => AttributeKind::Coroutine,
            Self::Coverage(__self_0) =>
                AttributeKind::Coverage(::core::clone::Clone::clone(__self_0)),
            Self::CrateName {
                name: __self_0, name_span: __self_1, attr_span: __self_2 } =>
                AttributeKind::CrateName {
                    name: ::core::clone::Clone::clone(__self_0),
                    name_span: ::core::clone::Clone::clone(__self_1),
                    attr_span: ::core::clone::Clone::clone(__self_2),
                },
            Self::CrateType(__self_0) =>
                AttributeKind::CrateType(::core::clone::Clone::clone(__self_0)),
            Self::CustomMir(__self_0, __self_1) =>
                AttributeKind::CustomMir(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::DebuggerVisualizer(__self_0) =>
                AttributeKind::DebuggerVisualizer(::core::clone::Clone::clone(__self_0)),
            Self::DefaultLibAllocator => AttributeKind::DefaultLibAllocator,
            Self::Deprecated {
                deprecation: __self_0, span: __self_1, is_inner: __self_2 } =>
                AttributeKind::Deprecated {
                    deprecation: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                    is_inner: ::core::clone::Clone::clone(__self_2),
                },
            Self::DoNotRecommend => AttributeKind::DoNotRecommend,
            Self::Doc(__self_0) =>
                AttributeKind::Doc(::core::clone::Clone::clone(__self_0)),
            Self::DocComment {
                style: __self_0,
                kind: __self_1,
                span: __self_2,
                comment: __self_3 } =>
                AttributeKind::DocComment {
                    style: ::core::clone::Clone::clone(__self_0),
                    kind: ::core::clone::Clone::clone(__self_1),
                    span: ::core::clone::Clone::clone(__self_2),
                    comment: ::core::clone::Clone::clone(__self_3),
                },
            Self::EiiDeclaration(__self_0) =>
                AttributeKind::EiiDeclaration(::core::clone::Clone::clone(__self_0)),
            Self::EiiImpl(__self_0) =>
                AttributeKind::EiiImpl(::core::clone::Clone::clone(__self_0)),
            Self::ExportName { name: __self_0, span: __self_1 } =>
                AttributeKind::ExportName {
                    name: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::ExportStable => AttributeKind::ExportStable,
            Self::Feature(__self_0, __self_1) =>
                AttributeKind::Feature(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::FfiConst => AttributeKind::FfiConst,
            Self::FfiPure(__self_0) =>
                AttributeKind::FfiPure(::core::clone::Clone::clone(__self_0)),
            Self::Fundamental => AttributeKind::Fundamental,
            Self::Ignore { span: __self_0, reason: __self_1 } =>
                AttributeKind::Ignore {
                    span: ::core::clone::Clone::clone(__self_0),
                    reason: ::core::clone::Clone::clone(__self_1),
                },
            Self::Inline(__self_0, __self_1) =>
                AttributeKind::Inline(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::InstructionSet(__self_0) =>
                AttributeKind::InstructionSet(::core::clone::Clone::clone(__self_0)),
            Self::InstrumentFn(__self_0) =>
                AttributeKind::InstrumentFn(::core::clone::Clone::clone(__self_0)),
            Self::Lang(__self_0) =>
                AttributeKind::Lang(::core::clone::Clone::clone(__self_0)),
            Self::Link(__self_0, __self_1) =>
                AttributeKind::Link(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::LinkName { name: __self_0, span: __self_1 } =>
                AttributeKind::LinkName {
                    name: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::LinkOrdinal { ordinal: __self_0, span: __self_1 } =>
                AttributeKind::LinkOrdinal {
                    ordinal: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::LinkSection { name: __self_0 } =>
                AttributeKind::LinkSection {
                    name: ::core::clone::Clone::clone(__self_0),
                },
            Self::Linkage(__self_0, __self_1) =>
                AttributeKind::Linkage(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::LintAsPtr => AttributeKind::LintAsPtr,
            Self::LintCheck(__self_0) =>
                AttributeKind::LintCheck(::core::clone::Clone::clone(__self_0)),
            Self::LintNeverReturnsNullPtr =>
                AttributeKind::LintNeverReturnsNullPtr,
            Self::LintShouldNotBeCalledOnConstItems =>
                AttributeKind::LintShouldNotBeCalledOnConstItems,
            Self::LoopMatch(__self_0) =>
                AttributeKind::LoopMatch(::core::clone::Clone::clone(__self_0)),
            Self::MacroEscape => AttributeKind::MacroEscape,
            Self::MacroExport { span: __self_0, local_inner_macros: __self_1 }
                =>
                AttributeKind::MacroExport {
                    span: ::core::clone::Clone::clone(__self_0),
                    local_inner_macros: ::core::clone::Clone::clone(__self_1),
                },
            Self::MacroUse { span: __self_0, arguments: __self_1 } =>
                AttributeKind::MacroUse {
                    span: ::core::clone::Clone::clone(__self_0),
                    arguments: ::core::clone::Clone::clone(__self_1),
                },
            Self::Marker => AttributeKind::Marker,
            Self::MayDangle(__self_0) =>
                AttributeKind::MayDangle(::core::clone::Clone::clone(__self_0)),
            Self::MoveSizeLimit { limit: __self_0 } =>
                AttributeKind::MoveSizeLimit {
                    limit: ::core::clone::Clone::clone(__self_0),
                },
            Self::MustNotSupend { reason: __self_0 } =>
                AttributeKind::MustNotSupend {
                    reason: ::core::clone::Clone::clone(__self_0),
                },
            Self::MustUse { span: __self_0, reason: __self_1 } =>
                AttributeKind::MustUse {
                    span: ::core::clone::Clone::clone(__self_0),
                    reason: ::core::clone::Clone::clone(__self_1),
                },
            Self::Naked(__self_0) =>
                AttributeKind::Naked(::core::clone::Clone::clone(__self_0)),
            Self::NeedsAllocator => AttributeKind::NeedsAllocator,
            Self::NeedsPanicRuntime => AttributeKind::NeedsPanicRuntime,
            Self::NoBuiltins => AttributeKind::NoBuiltins,
            Self::NoCore => AttributeKind::NoCore,
            Self::NoImplicitPrelude => AttributeKind::NoImplicitPrelude,
            Self::NoLink => AttributeKind::NoLink,
            Self::NoMain => AttributeKind::NoMain,
            Self::NoMangle(__self_0) =>
                AttributeKind::NoMangle(::core::clone::Clone::clone(__self_0)),
            Self::NoStd => AttributeKind::NoStd,
            Self::NonExhaustive(__self_0) =>
                AttributeKind::NonExhaustive(::core::clone::Clone::clone(__self_0)),
            Self::OnConst { span: __self_0, directive: __self_1 } =>
                AttributeKind::OnConst {
                    span: ::core::clone::Clone::clone(__self_0),
                    directive: ::core::clone::Clone::clone(__self_1),
                },
            Self::OnMove { directive: __self_0 } =>
                AttributeKind::OnMove {
                    directive: ::core::clone::Clone::clone(__self_0),
                },
            Self::OnTypeError { span: __self_0, directive: __self_1 } =>
                AttributeKind::OnTypeError {
                    span: ::core::clone::Clone::clone(__self_0),
                    directive: ::core::clone::Clone::clone(__self_1),
                },
            Self::OnUnimplemented { directive: __self_0 } =>
                AttributeKind::OnUnimplemented {
                    directive: ::core::clone::Clone::clone(__self_0),
                },
            Self::OnUnknown { directive: __self_0 } =>
                AttributeKind::OnUnknown {
                    directive: ::core::clone::Clone::clone(__self_0),
                },
            Self::OnUnmatchedArgs { directive: __self_0 } =>
                AttributeKind::OnUnmatchedArgs {
                    directive: ::core::clone::Clone::clone(__self_0),
                },
            Self::Opaque => AttributeKind::Opaque,
            Self::Optimize(__self_0, __self_1) =>
                AttributeKind::Optimize(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::PanicRuntime => AttributeKind::PanicRuntime,
            Self::PatchableFunctionEntry {
                prefix: __self_0, entry: __self_1, section: __self_2 } =>
                AttributeKind::PatchableFunctionEntry {
                    prefix: ::core::clone::Clone::clone(__self_0),
                    entry: ::core::clone::Clone::clone(__self_1),
                    section: ::core::clone::Clone::clone(__self_2),
                },
            Self::Path(__self_0, __self_1) =>
                AttributeKind::Path(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::PatternComplexityLimit { limit: __self_0 } =>
                AttributeKind::PatternComplexityLimit {
                    limit: ::core::clone::Clone::clone(__self_0),
                },
            Self::PinV2(__self_0) =>
                AttributeKind::PinV2(::core::clone::Clone::clone(__self_0)),
            Self::PreludeImport => AttributeKind::PreludeImport,
            Self::ProcMacro => AttributeKind::ProcMacro,
            Self::ProcMacroAttribute => AttributeKind::ProcMacroAttribute,
            Self::ProcMacroDerive {
                trait_name: __self_0, helper_attrs: __self_1 } =>
                AttributeKind::ProcMacroDerive {
                    trait_name: ::core::clone::Clone::clone(__self_0),
                    helper_attrs: ::core::clone::Clone::clone(__self_1),
                },
            Self::ProfilerRuntime => AttributeKind::ProfilerRuntime,
            Self::RecursionLimit { limit: __self_0 } =>
                AttributeKind::RecursionLimit {
                    limit: ::core::clone::Clone::clone(__self_0),
                },
            Self::ReexportTestHarnessMain(__self_0) =>
                AttributeKind::ReexportTestHarnessMain(::core::clone::Clone::clone(__self_0)),
            Self::RegisterTool { attr_tools: __self_0, lint_tools: __self_1 }
                =>
                AttributeKind::RegisterTool {
                    attr_tools: ::core::clone::Clone::clone(__self_0),
                    lint_tools: ::core::clone::Clone::clone(__self_1),
                },
            Self::Repr { reprs: __self_0, first_span: __self_1 } =>
                AttributeKind::Repr {
                    reprs: ::core::clone::Clone::clone(__self_0),
                    first_span: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcAbi { attr_span: __self_0, kind: __self_1 } =>
                AttributeKind::RustcAbi {
                    attr_span: ::core::clone::Clone::clone(__self_0),
                    kind: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcAlign { align: __self_0, span: __self_1 } =>
                AttributeKind::RustcAlign {
                    align: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcAllocator => AttributeKind::RustcAllocator,
            Self::RustcAllocatorZeroed => AttributeKind::RustcAllocatorZeroed,
            Self::RustcAllocatorZeroedVariant { name: __self_0 } =>
                AttributeKind::RustcAllocatorZeroedVariant {
                    name: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcAllowConstFnUnstable(__self_0, __self_1) =>
                AttributeKind::RustcAllowConstFnUnstable(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::RustcAllowIncoherentImpl(__self_0) =>
                AttributeKind::RustcAllowIncoherentImpl(::core::clone::Clone::clone(__self_0)),
            Self::RustcAllowLifetimeDependentSpecialization =>
                AttributeKind::RustcAllowLifetimeDependentSpecialization,
            Self::RustcAssertVariance { span: __self_0, kind: __self_1 } =>
                AttributeKind::RustcAssertVariance {
                    span: ::core::clone::Clone::clone(__self_0),
                    kind: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcAutodiff(__self_0) =>
                AttributeKind::RustcAutodiff(::core::clone::Clone::clone(__self_0)),
            Self::RustcBodyStability { stability: __self_0, span: __self_1 }
                =>
                AttributeKind::RustcBodyStability {
                    stability: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcBuiltinMacro {
                builtin_name: __self_0, helper_attrs: __self_1 } =>
                AttributeKind::RustcBuiltinMacro {
                    builtin_name: ::core::clone::Clone::clone(__self_0),
                    helper_attrs: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcCanonicalSymbol => AttributeKind::RustcCanonicalSymbol,
            Self::RustcCaptureAnalysis => AttributeKind::RustcCaptureAnalysis,
            Self::RustcCguTestAttr(__self_0) =>
                AttributeKind::RustcCguTestAttr(::core::clone::Clone::clone(__self_0)),
            Self::RustcClean(__self_0) =>
                AttributeKind::RustcClean(::core::clone::Clone::clone(__self_0)),
            Self::RustcCoherenceIsCore => AttributeKind::RustcCoherenceIsCore,
            Self::RustcCoinductive => AttributeKind::RustcCoinductive,
            Self::RustcComptime(__self_0) =>
                AttributeKind::RustcComptime(::core::clone::Clone::clone(__self_0)),
            Self::RustcConfusables { confusables: __self_0 } =>
                AttributeKind::RustcConfusables {
                    confusables: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcConstStability { stability: __self_0, span: __self_1 }
                =>
                AttributeKind::RustcConstStability {
                    stability: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcConstStableIndirect =>
                AttributeKind::RustcConstStableIndirect,
            Self::RustcConversionSuggestion =>
                AttributeKind::RustcConversionSuggestion,
            Self::RustcDeallocator => AttributeKind::RustcDeallocator,
            Self::RustcDelayedBugFromInsideQuery =>
                AttributeKind::RustcDelayedBugFromInsideQuery,
            Self::RustcDenyExplicitImpl =>
                AttributeKind::RustcDenyExplicitImpl,
            Self::RustcDeprecatedSafe2024 { suggestion: __self_0 } =>
                AttributeKind::RustcDeprecatedSafe2024 {
                    suggestion: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcDiagnosticItem(__self_0) =>
                AttributeKind::RustcDiagnosticItem(::core::clone::Clone::clone(__self_0)),
            Self::RustcDoNotConstCheck => AttributeKind::RustcDoNotConstCheck,
            Self::RustcDocPrimitive(__self_0, __self_1) =>
                AttributeKind::RustcDocPrimitive(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::RustcDummy => AttributeKind::RustcDummy,
            Self::RustcDumpClauses => AttributeKind::RustcDumpClauses,
            Self::RustcDumpDefParents => AttributeKind::RustcDumpDefParents,
            Self::RustcDumpDefPath(__self_0) =>
                AttributeKind::RustcDumpDefPath(::core::clone::Clone::clone(__self_0)),
            Self::RustcDumpGenerics => AttributeKind::RustcDumpGenerics,
            Self::RustcDumpHiddenTypeOfOpaques =>
                AttributeKind::RustcDumpHiddenTypeOfOpaques,
            Self::RustcDumpInferredOutlives =>
                AttributeKind::RustcDumpInferredOutlives,
            Self::RustcDumpItemBounds => AttributeKind::RustcDumpItemBounds,
            Self::RustcDumpLayout(__self_0) =>
                AttributeKind::RustcDumpLayout(::core::clone::Clone::clone(__self_0)),
            Self::RustcDumpObjectLifetimeDefaults =>
                AttributeKind::RustcDumpObjectLifetimeDefaults,
            Self::RustcDumpSymbolName(__self_0) =>
                AttributeKind::RustcDumpSymbolName(::core::clone::Clone::clone(__self_0)),
            Self::RustcDumpUserArgs => AttributeKind::RustcDumpUserArgs,
            Self::RustcDumpVariances => AttributeKind::RustcDumpVariances,
            Self::RustcDumpVariancesOfOpaques =>
                AttributeKind::RustcDumpVariancesOfOpaques,
            Self::RustcDumpVtable(__self_0) =>
                AttributeKind::RustcDumpVtable(::core::clone::Clone::clone(__self_0)),
            Self::RustcDynIncompatibleTrait(__self_0) =>
                AttributeKind::RustcDynIncompatibleTrait(::core::clone::Clone::clone(__self_0)),
            Self::RustcEffectiveVisibility =>
                AttributeKind::RustcEffectiveVisibility,
            Self::RustcEiiForeignItem => AttributeKind::RustcEiiForeignItem,
            Self::RustcEvaluateWhereClauses =>
                AttributeKind::RustcEvaluateWhereClauses,
            Self::RustcHasIncoherentInherentImpls =>
                AttributeKind::RustcHasIncoherentInherentImpls,
            Self::RustcIfThisChanged(__self_0, __self_1) =>
                AttributeKind::RustcIfThisChanged(::core::clone::Clone::clone(__self_0),
                    ::core::clone::Clone::clone(__self_1)),
            Self::RustcInheritOverflowChecks =>
                AttributeKind::RustcInheritOverflowChecks,
            Self::RustcInsignificantDtor =>
                AttributeKind::RustcInsignificantDtor,
            Self::RustcIntrinsic => AttributeKind::RustcIntrinsic,
            Self::RustcIntrinsicConstStableIndirect =>
                AttributeKind::RustcIntrinsicConstStableIndirect,
            Self::RustcLegacyConstGenerics {
                fn_indexes: __self_0, attr_span: __self_1 } =>
                AttributeKind::RustcLegacyConstGenerics {
                    fn_indexes: ::core::clone::Clone::clone(__self_0),
                    attr_span: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcLintOptDenyFieldAccess { lint_message: __self_0 } =>
                AttributeKind::RustcLintOptDenyFieldAccess {
                    lint_message: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcLintOptTy => AttributeKind::RustcLintOptTy,
            Self::RustcLintQueryInstability =>
                AttributeKind::RustcLintQueryInstability,
            Self::RustcLintUntrackedQueryInformation =>
                AttributeKind::RustcLintUntrackedQueryInformation,
            Self::RustcMacroTransparency(__self_0) =>
                AttributeKind::RustcMacroTransparency(::core::clone::Clone::clone(__self_0)),
            Self::RustcMain => AttributeKind::RustcMain,
            Self::RustcMir(__self_0) =>
                AttributeKind::RustcMir(::core::clone::Clone::clone(__self_0)),
            Self::RustcMustImplementOneOf {
                attr_span: __self_0, fn_names: __self_1 } =>
                AttributeKind::RustcMustImplementOneOf {
                    attr_span: ::core::clone::Clone::clone(__self_0),
                    fn_names: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcMustMatchExhaustively(__self_0) =>
                AttributeKind::RustcMustMatchExhaustively(::core::clone::Clone::clone(__self_0)),
            Self::RustcNoImplicitAutorefs =>
                AttributeKind::RustcNoImplicitAutorefs,
            Self::RustcNoImplicitBounds =>
                AttributeKind::RustcNoImplicitBounds,
            Self::RustcNoMirInline => AttributeKind::RustcNoMirInline,
            Self::RustcNoWritable => AttributeKind::RustcNoWritable,
            Self::RustcNonConstTraitMethod =>
                AttributeKind::RustcNonConstTraitMethod,
            Self::RustcNonnullOptimizationGuaranteed =>
                AttributeKind::RustcNonnullOptimizationGuaranteed,
            Self::RustcNounwind => AttributeKind::RustcNounwind,
            Self::RustcObjcClass { classname: __self_0 } =>
                AttributeKind::RustcObjcClass {
                    classname: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcObjcSelector { methname: __self_0 } =>
                AttributeKind::RustcObjcSelector {
                    methname: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcOffloadKernel => AttributeKind::RustcOffloadKernel,
            Self::RustcPanicsWhenZero => AttributeKind::RustcPanicsWhenZero,
            Self::RustcParenSugar => AttributeKind::RustcParenSugar,
            Self::RustcPassByValue => AttributeKind::RustcPassByValue,
            Self::RustcPassIndirectlyInNonRusticAbis(__self_0) =>
                AttributeKind::RustcPassIndirectlyInNonRusticAbis(::core::clone::Clone::clone(__self_0)),
            Self::RustcPreserveUbChecks =>
                AttributeKind::RustcPreserveUbChecks,
            Self::RustcProcMacroDecls => AttributeKind::RustcProcMacroDecls,
            Self::RustcPubTransparent(__self_0) =>
                AttributeKind::RustcPubTransparent(::core::clone::Clone::clone(__self_0)),
            Self::RustcReallocator => AttributeKind::RustcReallocator,
            Self::RustcRegions => AttributeKind::RustcRegions,
            Self::RustcScalableVector { element_count: __self_0 } =>
                AttributeKind::RustcScalableVector {
                    element_count: ::core::clone::Clone::clone(__self_0),
                },
            Self::RustcShouldNotBeCalledOnConstItems =>
                AttributeKind::RustcShouldNotBeCalledOnConstItems,
            Self::RustcShowSpans(__self_0) =>
                AttributeKind::RustcShowSpans(::core::clone::Clone::clone(__self_0)),
            Self::RustcSimdMonomorphizeLaneLimit(__self_0) =>
                AttributeKind::RustcSimdMonomorphizeLaneLimit(::core::clone::Clone::clone(__self_0)),
            Self::RustcSkipDuringMethodDispatch {
                array: __self_0, boxed_slice: __self_1 } =>
                AttributeKind::RustcSkipDuringMethodDispatch {
                    array: ::core::clone::Clone::clone(__self_0),
                    boxed_slice: ::core::clone::Clone::clone(__self_1),
                },
            Self::RustcSpecializationTrait =>
                AttributeKind::RustcSpecializationTrait,
            Self::RustcStdInternalSymbol =>
                AttributeKind::RustcStdInternalSymbol,
            Self::RustcStrictCoherence(__self_0) =>
                AttributeKind::RustcStrictCoherence(::core::clone::Clone::clone(__self_0)),
            Self::RustcTestMarker(__self_0) =>
                AttributeKind::RustcTestMarker(::core::clone::Clone::clone(__self_0)),
            Self::RustcThenThisWouldNeed(__self_0) =>
                AttributeKind::RustcThenThisWouldNeed(::core::clone::Clone::clone(__self_0)),
            Self::RustcTrivialFieldReads =>
                AttributeKind::RustcTrivialFieldReads,
            Self::Sanitize {
                on_set: __self_0,
                off_set: __self_1,
                rtsan: __self_2,
                span: __self_3 } =>
                AttributeKind::Sanitize {
                    on_set: ::core::clone::Clone::clone(__self_0),
                    off_set: ::core::clone::Clone::clone(__self_1),
                    rtsan: ::core::clone::Clone::clone(__self_2),
                    span: ::core::clone::Clone::clone(__self_3),
                },
            Self::ShouldPanic { reason: __self_0 } =>
                AttributeKind::ShouldPanic {
                    reason: ::core::clone::Clone::clone(__self_0),
                },
            Self::Splat(__self_0) =>
                AttributeKind::Splat(::core::clone::Clone::clone(__self_0)),
            Self::Stability { stability: __self_0, span: __self_1 } =>
                AttributeKind::Stability {
                    stability: ::core::clone::Clone::clone(__self_0),
                    span: ::core::clone::Clone::clone(__self_1),
                },
            Self::TargetFeature {
                features: __self_0, attr_span: __self_1, was_forced: __self_2
                } =>
                AttributeKind::TargetFeature {
                    features: ::core::clone::Clone::clone(__self_0),
                    attr_span: ::core::clone::Clone::clone(__self_1),
                    was_forced: ::core::clone::Clone::clone(__self_2),
                },
            Self::TestRunner(__self_0) =>
                AttributeKind::TestRunner(::core::clone::Clone::clone(__self_0)),
            Self::ThreadLocal => AttributeKind::ThreadLocal,
            Self::TrackCaller(__self_0) =>
                AttributeKind::TrackCaller(::core::clone::Clone::clone(__self_0)),
            Self::TypeLengthLimit { limit: __self_0 } =>
                AttributeKind::TypeLengthLimit {
                    limit: ::core::clone::Clone::clone(__self_0),
                },
            Self::UncheckedTypeAlias => AttributeKind::UncheckedTypeAlias,
            Self::Unroll(__self_0) =>
                AttributeKind::Unroll(::core::clone::Clone::clone(__self_0)),
            Self::UnstableFeatureBound(__self_0) =>
                AttributeKind::UnstableFeatureBound(::core::clone::Clone::clone(__self_0)),
            Self::UnstableRemoved(__self_0) =>
                AttributeKind::UnstableRemoved(::core::clone::Clone::clone(__self_0)),
            Self::Used { used_by: __self_0 } =>
                AttributeKind::Used {
                    used_by: ::core::clone::Clone::clone(__self_0),
                },
            Self::WindowsSubsystem(__self_0) =>
                AttributeKind::WindowsSubsystem(::core::clone::Clone::clone(__self_0)),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for AttributeKind {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::AllowInternalUnsafe(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "AllowInternalUnsafe", &__self_0),
            Self::AllowInternalUnstable(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "AllowInternalUnstable", __self_0, &__self_1),
            Self::AlwaysGca =>
                ::core::fmt::Formatter::write_str(f, "AlwaysGca"),
            Self::AutomaticallyDerived =>
                ::core::fmt::Formatter::write_str(f, "AutomaticallyDerived"),
            Self::CfgAttrTrace(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "CfgAttrTrace", &__self_0),
            Self::CfgTrace(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "CfgTrace", &__self_0),
            Self::CfiEncoding { encoding: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "CfiEncoding encoding", &__self_0),
            Self::Cold => ::core::fmt::Formatter::write_str(f, "Cold"),
            Self::CollapseDebugInfo(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "CollapseDebugInfo", &__self_0),
            Self::CompilerBuiltins =>
                ::core::fmt::Formatter::write_str(f, "CompilerBuiltins"),
            Self::ConstContinue(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "ConstContinue", &__self_0),
            Self::Coroutine =>
                ::core::fmt::Formatter::write_str(f, "Coroutine"),
            Self::Coverage(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Coverage", &__self_0),
            Self::CrateName {
                name: __self_0, name_span: __self_1, attr_span: __self_2 } =>
                ::core::fmt::Formatter::debug_struct_field3_finish(f,
                    "CrateName name name_span attr_span", __self_0, __self_1,
                    &__self_2),
            Self::CrateType(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "CrateType", &__self_0),
            Self::CustomMir(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "CustomMir", __self_0, &__self_1),
            Self::DebuggerVisualizer(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "DebuggerVisualizer", &__self_0),
            Self::DefaultLibAllocator =>
                ::core::fmt::Formatter::write_str(f, "DefaultLibAllocator"),
            Self::Deprecated {
                deprecation: __self_0, span: __self_1, is_inner: __self_2 } =>
                ::core::fmt::Formatter::debug_struct_field3_finish(f,
                    "Deprecated deprecation span is_inner", __self_0, __self_1,
                    &__self_2),
            Self::DoNotRecommend =>
                ::core::fmt::Formatter::write_str(f, "DoNotRecommend"),
            Self::Doc(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Doc",
                    &__self_0),
            Self::DocComment {
                style: __self_0,
                kind: __self_1,
                span: __self_2,
                comment: __self_3 } =>
                ::core::fmt::Formatter::debug_struct_field4_finish(f,
                    "DocComment style kind span comment", __self_0, __self_1,
                    __self_2, &__self_3),
            Self::EiiDeclaration(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "EiiDeclaration", &__self_0),
            Self::EiiImpl(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "EiiImpl", &__self_0),
            Self::ExportName { name: __self_0, span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "ExportName name span", __self_0, &__self_1),
            Self::ExportStable =>
                ::core::fmt::Formatter::write_str(f, "ExportStable"),
            Self::Feature(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Feature", __self_0, &__self_1),
            Self::FfiConst =>
                ::core::fmt::Formatter::write_str(f, "FfiConst"),
            Self::FfiPure(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "FfiPure", &__self_0),
            Self::Fundamental =>
                ::core::fmt::Formatter::write_str(f, "Fundamental"),
            Self::Ignore { span: __self_0, reason: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Ignore span reason", __self_0, &__self_1),
            Self::Inline(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Inline", __self_0, &__self_1),
            Self::InstructionSet(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "InstructionSet", &__self_0),
            Self::InstrumentFn(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "InstrumentFn", &__self_0),
            Self::Lang(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Lang",
                    &__self_0),
            Self::Link(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f, "Link",
                    __self_0, &__self_1),
            Self::LinkName { name: __self_0, span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "LinkName name span", __self_0, &__self_1),
            Self::LinkOrdinal { ordinal: __self_0, span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "LinkOrdinal ordinal span", __self_0, &__self_1),
            Self::LinkSection { name: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "LinkSection name", &__self_0),
            Self::Linkage(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Linkage", __self_0, &__self_1),
            Self::LintAsPtr =>
                ::core::fmt::Formatter::write_str(f, "LintAsPtr"),
            Self::LintCheck(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "LintCheck", &__self_0),
            Self::LintNeverReturnsNullPtr =>
                ::core::fmt::Formatter::write_str(f,
                    "LintNeverReturnsNullPtr"),
            Self::LintShouldNotBeCalledOnConstItems =>
                ::core::fmt::Formatter::write_str(f,
                    "LintShouldNotBeCalledOnConstItems"),
            Self::LoopMatch(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "LoopMatch", &__self_0),
            Self::MacroEscape =>
                ::core::fmt::Formatter::write_str(f, "MacroEscape"),
            Self::MacroExport { span: __self_0, local_inner_macros: __self_1 }
                =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "MacroExport span local_inner_macros", __self_0, &__self_1),
            Self::MacroUse { span: __self_0, arguments: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "MacroUse span arguments", __self_0, &__self_1),
            Self::Marker => ::core::fmt::Formatter::write_str(f, "Marker"),
            Self::MayDangle(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "MayDangle", &__self_0),
            Self::MoveSizeLimit { limit: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "MoveSizeLimit limit", &__self_0),
            Self::MustNotSupend { reason: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "MustNotSupend reason", &__self_0),
            Self::MustUse { span: __self_0, reason: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "MustUse span reason", __self_0, &__self_1),
            Self::Naked(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Naked",
                    &__self_0),
            Self::NeedsAllocator =>
                ::core::fmt::Formatter::write_str(f, "NeedsAllocator"),
            Self::NeedsPanicRuntime =>
                ::core::fmt::Formatter::write_str(f, "NeedsPanicRuntime"),
            Self::NoBuiltins =>
                ::core::fmt::Formatter::write_str(f, "NoBuiltins"),
            Self::NoCore => ::core::fmt::Formatter::write_str(f, "NoCore"),
            Self::NoImplicitPrelude =>
                ::core::fmt::Formatter::write_str(f, "NoImplicitPrelude"),
            Self::NoLink => ::core::fmt::Formatter::write_str(f, "NoLink"),
            Self::NoMain => ::core::fmt::Formatter::write_str(f, "NoMain"),
            Self::NoMangle(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "NoMangle", &__self_0),
            Self::NoStd => ::core::fmt::Formatter::write_str(f, "NoStd"),
            Self::NonExhaustive(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "NonExhaustive", &__self_0),
            Self::OnConst { span: __self_0, directive: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "OnConst span directive", __self_0, &__self_1),
            Self::OnMove { directive: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "OnMove directive", &__self_0),
            Self::OnTypeError { span: __self_0, directive: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "OnTypeError span directive", __self_0, &__self_1),
            Self::OnUnimplemented { directive: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "OnUnimplemented directive", &__self_0),
            Self::OnUnknown { directive: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "OnUnknown directive", &__self_0),
            Self::OnUnmatchedArgs { directive: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "OnUnmatchedArgs directive", &__self_0),
            Self::Opaque => ::core::fmt::Formatter::write_str(f, "Opaque"),
            Self::Optimize(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Optimize", __self_0, &__self_1),
            Self::PanicRuntime =>
                ::core::fmt::Formatter::write_str(f, "PanicRuntime"),
            Self::PatchableFunctionEntry {
                prefix: __self_0, entry: __self_1, section: __self_2 } =>
                ::core::fmt::Formatter::debug_struct_field3_finish(f,
                    "PatchableFunctionEntry prefix entry section", __self_0,
                    __self_1, &__self_2),
            Self::Path(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f, "Path",
                    __self_0, &__self_1),
            Self::PatternComplexityLimit { limit: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "PatternComplexityLimit limit", &__self_0),
            Self::PinV2(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "PinV2",
                    &__self_0),
            Self::PreludeImport =>
                ::core::fmt::Formatter::write_str(f, "PreludeImport"),
            Self::ProcMacro =>
                ::core::fmt::Formatter::write_str(f, "ProcMacro"),
            Self::ProcMacroAttribute =>
                ::core::fmt::Formatter::write_str(f, "ProcMacroAttribute"),
            Self::ProcMacroDerive {
                trait_name: __self_0, helper_attrs: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "ProcMacroDerive trait_name helper_attrs", __self_0,
                    &__self_1),
            Self::ProfilerRuntime =>
                ::core::fmt::Formatter::write_str(f, "ProfilerRuntime"),
            Self::RecursionLimit { limit: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RecursionLimit limit", &__self_0),
            Self::ReexportTestHarnessMain(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "ReexportTestHarnessMain", &__self_0),
            Self::RegisterTool { attr_tools: __self_0, lint_tools: __self_1 }
                =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RegisterTool attr_tools lint_tools", __self_0, &__self_1),
            Self::Repr { reprs: __self_0, first_span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Repr reprs first_span", __self_0, &__self_1),
            Self::RustcAbi { attr_span: __self_0, kind: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcAbi attr_span kind", __self_0, &__self_1),
            Self::RustcAlign { align: __self_0, span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcAlign align span", __self_0, &__self_1),
            Self::RustcAllocator =>
                ::core::fmt::Formatter::write_str(f, "RustcAllocator"),
            Self::RustcAllocatorZeroed =>
                ::core::fmt::Formatter::write_str(f, "RustcAllocatorZeroed"),
            Self::RustcAllocatorZeroedVariant { name: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcAllocatorZeroedVariant name", &__self_0),
            Self::RustcAllowConstFnUnstable(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcAllowConstFnUnstable", __self_0, &__self_1),
            Self::RustcAllowIncoherentImpl(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcAllowIncoherentImpl", &__self_0),
            Self::RustcAllowLifetimeDependentSpecialization =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcAllowLifetimeDependentSpecialization"),
            Self::RustcAssertVariance { span: __self_0, kind: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcAssertVariance span kind", __self_0, &__self_1),
            Self::RustcAutodiff(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcAutodiff", &__self_0),
            Self::RustcBodyStability { stability: __self_0, span: __self_1 }
                =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcBodyStability stability span", __self_0, &__self_1),
            Self::RustcBuiltinMacro {
                builtin_name: __self_0, helper_attrs: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcBuiltinMacro builtin_name helper_attrs", __self_0,
                    &__self_1),
            Self::RustcCanonicalSymbol =>
                ::core::fmt::Formatter::write_str(f, "RustcCanonicalSymbol"),
            Self::RustcCaptureAnalysis =>
                ::core::fmt::Formatter::write_str(f, "RustcCaptureAnalysis"),
            Self::RustcCguTestAttr(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcCguTestAttr", &__self_0),
            Self::RustcClean(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcClean", &__self_0),
            Self::RustcCoherenceIsCore =>
                ::core::fmt::Formatter::write_str(f, "RustcCoherenceIsCore"),
            Self::RustcCoinductive =>
                ::core::fmt::Formatter::write_str(f, "RustcCoinductive"),
            Self::RustcComptime(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcComptime", &__self_0),
            Self::RustcConfusables { confusables: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcConfusables confusables", &__self_0),
            Self::RustcConstStability { stability: __self_0, span: __self_1 }
                =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcConstStability stability span", __self_0, &__self_1),
            Self::RustcConstStableIndirect =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcConstStableIndirect"),
            Self::RustcConversionSuggestion =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcConversionSuggestion"),
            Self::RustcDeallocator =>
                ::core::fmt::Formatter::write_str(f, "RustcDeallocator"),
            Self::RustcDelayedBugFromInsideQuery =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcDelayedBugFromInsideQuery"),
            Self::RustcDenyExplicitImpl =>
                ::core::fmt::Formatter::write_str(f, "RustcDenyExplicitImpl"),
            Self::RustcDeprecatedSafe2024 { suggestion: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDeprecatedSafe2024 suggestion", &__self_0),
            Self::RustcDiagnosticItem(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDiagnosticItem", &__self_0),
            Self::RustcDoNotConstCheck =>
                ::core::fmt::Formatter::write_str(f, "RustcDoNotConstCheck"),
            Self::RustcDocPrimitive(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcDocPrimitive", __self_0, &__self_1),
            Self::RustcDummy =>
                ::core::fmt::Formatter::write_str(f, "RustcDummy"),
            Self::RustcDumpClauses =>
                ::core::fmt::Formatter::write_str(f, "RustcDumpClauses"),
            Self::RustcDumpDefParents =>
                ::core::fmt::Formatter::write_str(f, "RustcDumpDefParents"),
            Self::RustcDumpDefPath(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDumpDefPath", &__self_0),
            Self::RustcDumpGenerics =>
                ::core::fmt::Formatter::write_str(f, "RustcDumpGenerics"),
            Self::RustcDumpHiddenTypeOfOpaques =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcDumpHiddenTypeOfOpaques"),
            Self::RustcDumpInferredOutlives =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcDumpInferredOutlives"),
            Self::RustcDumpItemBounds =>
                ::core::fmt::Formatter::write_str(f, "RustcDumpItemBounds"),
            Self::RustcDumpLayout(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDumpLayout", &__self_0),
            Self::RustcDumpObjectLifetimeDefaults =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcDumpObjectLifetimeDefaults"),
            Self::RustcDumpSymbolName(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDumpSymbolName", &__self_0),
            Self::RustcDumpUserArgs =>
                ::core::fmt::Formatter::write_str(f, "RustcDumpUserArgs"),
            Self::RustcDumpVariances =>
                ::core::fmt::Formatter::write_str(f, "RustcDumpVariances"),
            Self::RustcDumpVariancesOfOpaques =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcDumpVariancesOfOpaques"),
            Self::RustcDumpVtable(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDumpVtable", &__self_0),
            Self::RustcDynIncompatibleTrait(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcDynIncompatibleTrait", &__self_0),
            Self::RustcEffectiveVisibility =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcEffectiveVisibility"),
            Self::RustcEiiForeignItem =>
                ::core::fmt::Formatter::write_str(f, "RustcEiiForeignItem"),
            Self::RustcEvaluateWhereClauses =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcEvaluateWhereClauses"),
            Self::RustcHasIncoherentInherentImpls =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcHasIncoherentInherentImpls"),
            Self::RustcIfThisChanged(__self_0, __self_1) =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcIfThisChanged", __self_0, &__self_1),
            Self::RustcInheritOverflowChecks =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcInheritOverflowChecks"),
            Self::RustcInsignificantDtor =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcInsignificantDtor"),
            Self::RustcIntrinsic =>
                ::core::fmt::Formatter::write_str(f, "RustcIntrinsic"),
            Self::RustcIntrinsicConstStableIndirect =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcIntrinsicConstStableIndirect"),
            Self::RustcLegacyConstGenerics {
                fn_indexes: __self_0, attr_span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcLegacyConstGenerics fn_indexes attr_span", __self_0,
                    &__self_1),
            Self::RustcLintOptDenyFieldAccess { lint_message: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcLintOptDenyFieldAccess lint_message", &__self_0),
            Self::RustcLintOptTy =>
                ::core::fmt::Formatter::write_str(f, "RustcLintOptTy"),
            Self::RustcLintQueryInstability =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcLintQueryInstability"),
            Self::RustcLintUntrackedQueryInformation =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcLintUntrackedQueryInformation"),
            Self::RustcMacroTransparency(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcMacroTransparency", &__self_0),
            Self::RustcMain =>
                ::core::fmt::Formatter::write_str(f, "RustcMain"),
            Self::RustcMir(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcMir", &__self_0),
            Self::RustcMustImplementOneOf {
                attr_span: __self_0, fn_names: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcMustImplementOneOf attr_span fn_names", __self_0,
                    &__self_1),
            Self::RustcMustMatchExhaustively(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcMustMatchExhaustively", &__self_0),
            Self::RustcNoImplicitAutorefs =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcNoImplicitAutorefs"),
            Self::RustcNoImplicitBounds =>
                ::core::fmt::Formatter::write_str(f, "RustcNoImplicitBounds"),
            Self::RustcNoMirInline =>
                ::core::fmt::Formatter::write_str(f, "RustcNoMirInline"),
            Self::RustcNoWritable =>
                ::core::fmt::Formatter::write_str(f, "RustcNoWritable"),
            Self::RustcNonConstTraitMethod =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcNonConstTraitMethod"),
            Self::RustcNonnullOptimizationGuaranteed =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcNonnullOptimizationGuaranteed"),
            Self::RustcNounwind =>
                ::core::fmt::Formatter::write_str(f, "RustcNounwind"),
            Self::RustcObjcClass { classname: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcObjcClass classname", &__self_0),
            Self::RustcObjcSelector { methname: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcObjcSelector methname", &__self_0),
            Self::RustcOffloadKernel =>
                ::core::fmt::Formatter::write_str(f, "RustcOffloadKernel"),
            Self::RustcPanicsWhenZero =>
                ::core::fmt::Formatter::write_str(f, "RustcPanicsWhenZero"),
            Self::RustcParenSugar =>
                ::core::fmt::Formatter::write_str(f, "RustcParenSugar"),
            Self::RustcPassByValue =>
                ::core::fmt::Formatter::write_str(f, "RustcPassByValue"),
            Self::RustcPassIndirectlyInNonRusticAbis(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcPassIndirectlyInNonRusticAbis", &__self_0),
            Self::RustcPreserveUbChecks =>
                ::core::fmt::Formatter::write_str(f, "RustcPreserveUbChecks"),
            Self::RustcProcMacroDecls =>
                ::core::fmt::Formatter::write_str(f, "RustcProcMacroDecls"),
            Self::RustcPubTransparent(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcPubTransparent", &__self_0),
            Self::RustcReallocator =>
                ::core::fmt::Formatter::write_str(f, "RustcReallocator"),
            Self::RustcRegions =>
                ::core::fmt::Formatter::write_str(f, "RustcRegions"),
            Self::RustcScalableVector { element_count: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcScalableVector element_count", &__self_0),
            Self::RustcShouldNotBeCalledOnConstItems =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcShouldNotBeCalledOnConstItems"),
            Self::RustcShowSpans(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcShowSpans", &__self_0),
            Self::RustcSimdMonomorphizeLaneLimit(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcSimdMonomorphizeLaneLimit", &__self_0),
            Self::RustcSkipDuringMethodDispatch {
                array: __self_0, boxed_slice: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "RustcSkipDuringMethodDispatch array boxed_slice", __self_0,
                    &__self_1),
            Self::RustcSpecializationTrait =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcSpecializationTrait"),
            Self::RustcStdInternalSymbol =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcStdInternalSymbol"),
            Self::RustcStrictCoherence(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcStrictCoherence", &__self_0),
            Self::RustcTestMarker(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcTestMarker", &__self_0),
            Self::RustcThenThisWouldNeed(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcThenThisWouldNeed", &__self_0),
            Self::RustcTrivialFieldReads =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcTrivialFieldReads"),
            Self::Sanitize {
                on_set: __self_0,
                off_set: __self_1,
                rtsan: __self_2,
                span: __self_3 } =>
                ::core::fmt::Formatter::debug_struct_field4_finish(f,
                    "Sanitize on_set off_set rtsan span", __self_0, __self_1,
                    __self_2, &__self_3),
            Self::ShouldPanic { reason: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "ShouldPanic reason", &__self_0),
            Self::Splat(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f, "Splat",
                    &__self_0),
            Self::Stability { stability: __self_0, span: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Stability stability span", __self_0, &__self_1),
            Self::TargetFeature {
                features: __self_0, attr_span: __self_1, was_forced: __self_2
                } =>
                ::core::fmt::Formatter::debug_struct_field3_finish(f,
                    "TargetFeature features attr_span was_forced", __self_0,
                    __self_1, &__self_2),
            Self::TestRunner(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "TestRunner", &__self_0),
            Self::ThreadLocal =>
                ::core::fmt::Formatter::write_str(f, "ThreadLocal"),
            Self::TrackCaller(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "TrackCaller", &__self_0),
            Self::TypeLengthLimit { limit: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "TypeLengthLimit limit", &__self_0),
            Self::UncheckedTypeAlias =>
                ::core::fmt::Formatter::write_str(f, "UncheckedTypeAlias"),
            Self::Unroll(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Unroll", &__self_0),
            Self::UnstableFeatureBound(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "UnstableFeatureBound", &__self_0),
            Self::UnstableRemoved(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "UnstableRemoved", &__self_0),
            Self::Used { used_by: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Used used_by", &__self_0),
            Self::WindowsSubsystem(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "WindowsSubsystem", &__self_0),
        }
    }
}Debug, const _: () =
    {
        impl ::rustc_data_structures::stable_hash::StableHash for
            AttributeKind {
            #[inline]
            fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
                __hcx: &mut __Hcx,
                __hasher:
                    &mut ::rustc_data_structures::stable_hash::StableHasher) {
                match *self {
                    AttributeKind::AllowInternalUnsafe(ref __binding_0) =>
                        0u8.stable_hash(__hcx, __hasher),
                    AttributeKind::AllowInternalUnstable(ref __binding_0,
                        ref __binding_1) => 1u8.stable_hash(__hcx, __hasher),
                    AttributeKind::AlwaysGca =>
                        2u8.stable_hash(__hcx, __hasher),
                    AttributeKind::AutomaticallyDerived =>
                        3u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CfgAttrTrace(ref __binding_0) =>
                        4u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CfgTrace(ref __binding_0) =>
                        5u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
                        6u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Cold => 7u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CollapseDebugInfo(ref __binding_0) =>
                        8u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CompilerBuiltins =>
                        9u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ConstContinue(ref __binding_0) =>
                        10u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Coroutine =>
                        11u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Coverage(ref __binding_0) =>
                        12u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CrateName {
                        name: ref __binding_0,
                        name_span: ref __binding_1,
                        attr_span: ref __binding_2 } =>
                        13u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CrateType(ref __binding_0) =>
                        14u8.stable_hash(__hcx, __hasher),
                    AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
                        => 15u8.stable_hash(__hcx, __hasher),
                    AttributeKind::DebuggerVisualizer(ref __binding_0) =>
                        16u8.stable_hash(__hcx, __hasher),
                    AttributeKind::DefaultLibAllocator =>
                        17u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Deprecated {
                        deprecation: ref __binding_0,
                        span: ref __binding_1,
                        is_inner: ref __binding_2 } =>
                        18u8.stable_hash(__hcx, __hasher),
                    AttributeKind::DoNotRecommend =>
                        19u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Doc(ref __binding_0) =>
                        20u8.stable_hash(__hcx, __hasher),
                    AttributeKind::DocComment {
                        style: ref __binding_0,
                        kind: ref __binding_1,
                        span: ref __binding_2,
                        comment: ref __binding_3 } =>
                        21u8.stable_hash(__hcx, __hasher),
                    AttributeKind::EiiDeclaration(ref __binding_0) =>
                        22u8.stable_hash(__hcx, __hasher),
                    AttributeKind::EiiImpl(ref __binding_0) =>
                        23u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ExportName {
                        name: ref __binding_0, span: ref __binding_1 } =>
                        24u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ExportStable =>
                        25u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
                        26u8.stable_hash(__hcx, __hasher),
                    AttributeKind::FfiConst =>
                        27u8.stable_hash(__hcx, __hasher),
                    AttributeKind::FfiPure(ref __binding_0) =>
                        28u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Fundamental =>
                        29u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Ignore {
                        span: ref __binding_0, reason: ref __binding_1 } =>
                        30u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Inline(ref __binding_0, ref __binding_1) =>
                        31u8.stable_hash(__hcx, __hasher),
                    AttributeKind::InstructionSet(ref __binding_0) =>
                        32u8.stable_hash(__hcx, __hasher),
                    AttributeKind::InstrumentFn(ref __binding_0) =>
                        33u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Lang(ref __binding_0) =>
                        34u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Link(ref __binding_0, ref __binding_1) =>
                        35u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LinkName {
                        name: ref __binding_0, span: ref __binding_1 } =>
                        36u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LinkOrdinal {
                        ordinal: ref __binding_0, span: ref __binding_1 } =>
                        37u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LinkSection { name: ref __binding_0 } =>
                        38u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
                        39u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LintAsPtr =>
                        40u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LintCheck(ref __binding_0) =>
                        41u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LintNeverReturnsNullPtr =>
                        42u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LintShouldNotBeCalledOnConstItems =>
                        43u8.stable_hash(__hcx, __hasher),
                    AttributeKind::LoopMatch(ref __binding_0) =>
                        44u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MacroEscape =>
                        45u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MacroExport {
                        span: ref __binding_0, local_inner_macros: ref __binding_1 }
                        => 46u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MacroUse {
                        span: ref __binding_0, arguments: ref __binding_1 } =>
                        47u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Marker => 48u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MayDangle(ref __binding_0) =>
                        49u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MoveSizeLimit { limit: ref __binding_0 } =>
                        50u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MustNotSupend { reason: ref __binding_0 } =>
                        51u8.stable_hash(__hcx, __hasher),
                    AttributeKind::MustUse {
                        span: ref __binding_0, reason: ref __binding_1 } =>
                        52u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Naked(ref __binding_0) =>
                        53u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NeedsAllocator =>
                        54u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NeedsPanicRuntime =>
                        55u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoBuiltins =>
                        56u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoCore => 57u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoImplicitPrelude =>
                        58u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoLink => 59u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoMain => 60u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoMangle(ref __binding_0) =>
                        61u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NoStd => 62u8.stable_hash(__hcx, __hasher),
                    AttributeKind::NonExhaustive(ref __binding_0) =>
                        63u8.stable_hash(__hcx, __hasher),
                    AttributeKind::OnConst {
                        span: ref __binding_0, directive: ref __binding_1 } =>
                        64u8.stable_hash(__hcx, __hasher),
                    AttributeKind::OnMove { directive: ref __binding_0 } =>
                        65u8.stable_hash(__hcx, __hasher),
                    AttributeKind::OnTypeError {
                        span: ref __binding_0, directive: ref __binding_1 } =>
                        66u8.stable_hash(__hcx, __hasher),
                    AttributeKind::OnUnimplemented { directive: ref __binding_0
                        } => 67u8.stable_hash(__hcx, __hasher),
                    AttributeKind::OnUnknown { directive: ref __binding_0 } =>
                        68u8.stable_hash(__hcx, __hasher),
                    AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
                        } => 69u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Opaque => 70u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
                        71u8.stable_hash(__hcx, __hasher),
                    AttributeKind::PanicRuntime =>
                        72u8.stable_hash(__hcx, __hasher),
                    AttributeKind::PatchableFunctionEntry {
                        prefix: ref __binding_0,
                        entry: ref __binding_1,
                        section: ref __binding_2 } =>
                        73u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Path(ref __binding_0, ref __binding_1) =>
                        74u8.stable_hash(__hcx, __hasher),
                    AttributeKind::PatternComplexityLimit {
                        limit: ref __binding_0 } =>
                        75u8.stable_hash(__hcx, __hasher),
                    AttributeKind::PinV2(ref __binding_0) =>
                        76u8.stable_hash(__hcx, __hasher),
                    AttributeKind::PreludeImport =>
                        77u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ProcMacro =>
                        78u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ProcMacroAttribute =>
                        79u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ProcMacroDerive {
                        trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
                        => 80u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ProfilerRuntime =>
                        81u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
                        82u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ReexportTestHarnessMain(ref __binding_0) =>
                        83u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RegisterTool {
                        attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
                        => 84u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Repr {
                        reprs: ref __binding_0, first_span: ref __binding_1 } =>
                        85u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAbi {
                        attr_span: ref __binding_0, kind: ref __binding_1 } =>
                        86u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAlign {
                        align: ref __binding_0, span: ref __binding_1 } =>
                        87u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAllocator =>
                        88u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAllocatorZeroed =>
                        89u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAllocatorZeroedVariant {
                        name: ref __binding_0 } =>
                        90u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
                        ref __binding_1) => 91u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
                        92u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAllowLifetimeDependentSpecialization =>
                        93u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAssertVariance {
                        span: ref __binding_0, kind: ref __binding_1 } =>
                        94u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcAutodiff(ref __binding_0) =>
                        95u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcBodyStability {
                        stability: ref __binding_0, span: ref __binding_1 } =>
                        96u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcBuiltinMacro {
                        builtin_name: ref __binding_0, helper_attrs: ref __binding_1
                        } => 97u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcCanonicalSymbol =>
                        98u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcCaptureAnalysis =>
                        99u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcCguTestAttr(ref __binding_0) =>
                        100u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcClean(ref __binding_0) =>
                        101u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcCoherenceIsCore =>
                        102u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcCoinductive =>
                        103u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcComptime(ref __binding_0) =>
                        104u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcConfusables {
                        confusables: ref __binding_0 } =>
                        105u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcConstStability {
                        stability: ref __binding_0, span: ref __binding_1 } =>
                        106u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcConstStableIndirect =>
                        107u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcConversionSuggestion =>
                        108u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDeallocator =>
                        109u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDelayedBugFromInsideQuery =>
                        110u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDenyExplicitImpl =>
                        111u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDeprecatedSafe2024 {
                        suggestion: ref __binding_0 } =>
                        112u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDiagnosticItem(ref __binding_0) =>
                        113u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDoNotConstCheck =>
                        114u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDocPrimitive(ref __binding_0,
                        ref __binding_1) => 115u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDummy =>
                        116u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpClauses =>
                        117u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpDefParents =>
                        118u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpDefPath(ref __binding_0) =>
                        119u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpGenerics =>
                        120u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpHiddenTypeOfOpaques =>
                        121u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpInferredOutlives =>
                        122u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpItemBounds =>
                        123u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpLayout(ref __binding_0) =>
                        124u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpObjectLifetimeDefaults =>
                        125u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpSymbolName(ref __binding_0) =>
                        126u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpUserArgs =>
                        127u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpVariances =>
                        128u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpVariancesOfOpaques =>
                        129u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDumpVtable(ref __binding_0) =>
                        130u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
                        131u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcEffectiveVisibility =>
                        132u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcEiiForeignItem =>
                        133u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcEvaluateWhereClauses =>
                        134u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcHasIncoherentInherentImpls =>
                        135u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcIfThisChanged(ref __binding_0,
                        ref __binding_1) => 136u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcInheritOverflowChecks =>
                        137u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcInsignificantDtor =>
                        138u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcIntrinsic =>
                        139u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcIntrinsicConstStableIndirect =>
                        140u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcLegacyConstGenerics {
                        fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
                        141u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcLintOptDenyFieldAccess {
                        lint_message: ref __binding_0 } =>
                        142u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcLintOptTy =>
                        143u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcLintQueryInstability =>
                        144u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcLintUntrackedQueryInformation =>
                        145u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcMacroTransparency(ref __binding_0) =>
                        146u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcMain =>
                        147u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcMir(ref __binding_0) =>
                        148u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcMustImplementOneOf {
                        attr_span: ref __binding_0, fn_names: ref __binding_1 } =>
                        149u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
                        => 150u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNoImplicitAutorefs =>
                        151u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNoImplicitBounds =>
                        152u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNoMirInline =>
                        153u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNoWritable =>
                        154u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNonConstTraitMethod =>
                        155u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNonnullOptimizationGuaranteed =>
                        156u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcNounwind =>
                        157u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcObjcClass { classname: ref __binding_0 }
                        => 158u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcObjcSelector { methname: ref __binding_0
                        } => 159u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcOffloadKernel =>
                        160u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcPanicsWhenZero =>
                        161u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcParenSugar =>
                        162u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcPassByValue =>
                        163u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
                        => 164u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcPreserveUbChecks =>
                        165u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcProcMacroDecls =>
                        166u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcPubTransparent(ref __binding_0) =>
                        167u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcReallocator =>
                        168u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcRegions =>
                        169u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcScalableVector {
                        element_count: ref __binding_0 } =>
                        170u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcShouldNotBeCalledOnConstItems =>
                        171u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcShowSpans(ref __binding_0) =>
                        172u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
                        => 173u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcSkipDuringMethodDispatch {
                        array: ref __binding_0, boxed_slice: ref __binding_1 } =>
                        174u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcSpecializationTrait =>
                        175u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcStdInternalSymbol =>
                        176u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcStrictCoherence(ref __binding_0) =>
                        177u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcTestMarker(ref __binding_0) =>
                        178u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcThenThisWouldNeed(ref __binding_0) =>
                        179u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcTrivialFieldReads =>
                        180u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Sanitize {
                        on_set: ref __binding_0,
                        off_set: ref __binding_1,
                        rtsan: ref __binding_2,
                        span: ref __binding_3 } =>
                        181u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ShouldPanic { reason: ref __binding_0 } =>
                        182u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Splat(ref __binding_0) =>
                        183u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Stability {
                        stability: ref __binding_0, span: ref __binding_1 } =>
                        184u8.stable_hash(__hcx, __hasher),
                    AttributeKind::TargetFeature {
                        features: ref __binding_0,
                        attr_span: ref __binding_1,
                        was_forced: ref __binding_2 } =>
                        185u8.stable_hash(__hcx, __hasher),
                    AttributeKind::TestRunner(ref __binding_0) =>
                        186u8.stable_hash(__hcx, __hasher),
                    AttributeKind::ThreadLocal =>
                        187u8.stable_hash(__hcx, __hasher),
                    AttributeKind::TrackCaller(ref __binding_0) =>
                        188u8.stable_hash(__hcx, __hasher),
                    AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
                        189u8.stable_hash(__hcx, __hasher),
                    AttributeKind::UncheckedTypeAlias =>
                        190u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Unroll(ref __binding_0) =>
                        191u8.stable_hash(__hcx, __hasher),
                    AttributeKind::UnstableFeatureBound(ref __binding_0) =>
                        192u8.stable_hash(__hcx, __hasher),
                    AttributeKind::UnstableRemoved(ref __binding_0) =>
                        193u8.stable_hash(__hcx, __hasher),
                    AttributeKind::Used { used_by: ref __binding_0 } =>
                        194u8.stable_hash(__hcx, __hasher),
                    AttributeKind::WindowsSubsystem(ref __binding_0) =>
                        195u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    AttributeKind::AllowInternalUnsafe(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::AllowInternalUnstable(ref __binding_0,
                        ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::AlwaysGca => {}
                    AttributeKind::AutomaticallyDerived => {}
                    AttributeKind::CfgAttrTrace(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::CfgTrace(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Cold => {}
                    AttributeKind::CollapseDebugInfo(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::CompilerBuiltins => {}
                    AttributeKind::ConstContinue(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Coroutine => {}
                    AttributeKind::Coverage(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::CrateName {
                        name: ref __binding_0,
                        name_span: ref __binding_1,
                        attr_span: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::CrateType(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::DebuggerVisualizer(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::DefaultLibAllocator => {}
                    AttributeKind::Deprecated {
                        deprecation: ref __binding_0,
                        span: ref __binding_1,
                        is_inner: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::DoNotRecommend => {}
                    AttributeKind::Doc(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::DocComment {
                        style: ref __binding_0,
                        kind: ref __binding_1,
                        span: ref __binding_2,
                        comment: ref __binding_3 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::EiiDeclaration(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::EiiImpl(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::ExportName {
                        name: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::ExportStable => {}
                    AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::FfiConst => {}
                    AttributeKind::FfiPure(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Fundamental => {}
                    AttributeKind::Ignore {
                        span: ref __binding_0, reason: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Inline(ref __binding_0, ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::InstructionSet(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::InstrumentFn(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Lang(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Link(ref __binding_0, ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::LinkName {
                        name: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::LinkOrdinal {
                        ordinal: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::LinkSection { name: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::LintAsPtr => {}
                    AttributeKind::LintCheck(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::LintNeverReturnsNullPtr => {}
                    AttributeKind::LintShouldNotBeCalledOnConstItems => {}
                    AttributeKind::LoopMatch(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::MacroEscape => {}
                    AttributeKind::MacroExport {
                        span: ref __binding_0, local_inner_macros: ref __binding_1 }
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::MacroUse {
                        span: ref __binding_0, arguments: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Marker => {}
                    AttributeKind::MayDangle(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::MoveSizeLimit { limit: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::MustNotSupend { reason: ref __binding_0 } =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::MustUse {
                        span: ref __binding_0, reason: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Naked(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::NeedsAllocator => {}
                    AttributeKind::NeedsPanicRuntime => {}
                    AttributeKind::NoBuiltins => {}
                    AttributeKind::NoCore => {}
                    AttributeKind::NoImplicitPrelude => {}
                    AttributeKind::NoLink => {}
                    AttributeKind::NoMain => {}
                    AttributeKind::NoMangle(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::NoStd => {}
                    AttributeKind::NonExhaustive(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::OnConst {
                        span: ref __binding_0, directive: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::OnMove { directive: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::OnTypeError {
                        span: ref __binding_0, directive: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::OnUnimplemented { directive: ref __binding_0
                        } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::OnUnknown { directive: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
                        } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Opaque => {}
                    AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::PanicRuntime => {}
                    AttributeKind::PatchableFunctionEntry {
                        prefix: ref __binding_0,
                        entry: ref __binding_1,
                        section: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Path(ref __binding_0, ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::PatternComplexityLimit {
                        limit: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::PinV2(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::PreludeImport => {}
                    AttributeKind::ProcMacro => {}
                    AttributeKind::ProcMacroAttribute => {}
                    AttributeKind::ProcMacroDerive {
                        trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::ProfilerRuntime => {}
                    AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::ReexportTestHarnessMain(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RegisterTool {
                        attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Repr {
                        reprs: ref __binding_0, first_span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAbi {
                        attr_span: ref __binding_0, kind: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAlign {
                        align: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAllocator => {}
                    AttributeKind::RustcAllocatorZeroed => {}
                    AttributeKind::RustcAllocatorZeroedVariant {
                        name: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
                        ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAllowLifetimeDependentSpecialization =>
                        {}
                    AttributeKind::RustcAssertVariance {
                        span: ref __binding_0, kind: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcAutodiff(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcBodyStability {
                        stability: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcBuiltinMacro {
                        builtin_name: ref __binding_0, helper_attrs: ref __binding_1
                        } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcCanonicalSymbol => {}
                    AttributeKind::RustcCaptureAnalysis => {}
                    AttributeKind::RustcCguTestAttr(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcClean(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcCoherenceIsCore => {}
                    AttributeKind::RustcCoinductive => {}
                    AttributeKind::RustcComptime(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcConfusables {
                        confusables: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcConstStability {
                        stability: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcConstStableIndirect => {}
                    AttributeKind::RustcConversionSuggestion => {}
                    AttributeKind::RustcDeallocator => {}
                    AttributeKind::RustcDelayedBugFromInsideQuery => {}
                    AttributeKind::RustcDenyExplicitImpl => {}
                    AttributeKind::RustcDeprecatedSafe2024 {
                        suggestion: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDiagnosticItem(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDoNotConstCheck => {}
                    AttributeKind::RustcDocPrimitive(ref __binding_0,
                        ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDummy => {}
                    AttributeKind::RustcDumpClauses => {}
                    AttributeKind::RustcDumpDefParents => {}
                    AttributeKind::RustcDumpDefPath(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDumpGenerics => {}
                    AttributeKind::RustcDumpHiddenTypeOfOpaques => {}
                    AttributeKind::RustcDumpInferredOutlives => {}
                    AttributeKind::RustcDumpItemBounds => {}
                    AttributeKind::RustcDumpLayout(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDumpObjectLifetimeDefaults => {}
                    AttributeKind::RustcDumpSymbolName(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDumpUserArgs => {}
                    AttributeKind::RustcDumpVariances => {}
                    AttributeKind::RustcDumpVariancesOfOpaques => {}
                    AttributeKind::RustcDumpVtable(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcEffectiveVisibility => {}
                    AttributeKind::RustcEiiForeignItem => {}
                    AttributeKind::RustcEvaluateWhereClauses => {}
                    AttributeKind::RustcHasIncoherentInherentImpls => {}
                    AttributeKind::RustcIfThisChanged(ref __binding_0,
                        ref __binding_1) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcInheritOverflowChecks => {}
                    AttributeKind::RustcInsignificantDtor => {}
                    AttributeKind::RustcIntrinsic => {}
                    AttributeKind::RustcIntrinsicConstStableIndirect => {}
                    AttributeKind::RustcLegacyConstGenerics {
                        fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcLintOptDenyFieldAccess {
                        lint_message: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcLintOptTy => {}
                    AttributeKind::RustcLintQueryInstability => {}
                    AttributeKind::RustcLintUntrackedQueryInformation => {}
                    AttributeKind::RustcMacroTransparency(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcMain => {}
                    AttributeKind::RustcMir(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcMustImplementOneOf {
                        attr_span: ref __binding_0, fn_names: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcNoImplicitAutorefs => {}
                    AttributeKind::RustcNoImplicitBounds => {}
                    AttributeKind::RustcNoMirInline => {}
                    AttributeKind::RustcNoWritable => {}
                    AttributeKind::RustcNonConstTraitMethod => {}
                    AttributeKind::RustcNonnullOptimizationGuaranteed => {}
                    AttributeKind::RustcNounwind => {}
                    AttributeKind::RustcObjcClass { classname: ref __binding_0 }
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcObjcSelector { methname: ref __binding_0
                        } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcOffloadKernel => {}
                    AttributeKind::RustcPanicsWhenZero => {}
                    AttributeKind::RustcParenSugar => {}
                    AttributeKind::RustcPassByValue => {}
                    AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcPreserveUbChecks => {}
                    AttributeKind::RustcProcMacroDecls => {}
                    AttributeKind::RustcPubTransparent(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcReallocator => {}
                    AttributeKind::RustcRegions => {}
                    AttributeKind::RustcScalableVector {
                        element_count: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcShouldNotBeCalledOnConstItems => {}
                    AttributeKind::RustcShowSpans(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
                        => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcSkipDuringMethodDispatch {
                        array: ref __binding_0, boxed_slice: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcSpecializationTrait => {}
                    AttributeKind::RustcStdInternalSymbol => {}
                    AttributeKind::RustcStrictCoherence(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcTestMarker(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcTrivialFieldReads => {}
                    AttributeKind::Sanitize {
                        on_set: ref __binding_0,
                        off_set: ref __binding_1,
                        rtsan: ref __binding_2,
                        span: ref __binding_3 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                        { __binding_3.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::ShouldPanic { reason: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Splat(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Stability {
                        stability: ref __binding_0, span: ref __binding_1 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::TargetFeature {
                        features: ref __binding_0,
                        attr_span: ref __binding_1,
                        was_forced: ref __binding_2 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                        { __binding_1.stable_hash(__hcx, __hasher); }
                        { __binding_2.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::TestRunner(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::ThreadLocal => {}
                    AttributeKind::TrackCaller(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
                        {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::UncheckedTypeAlias => {}
                    AttributeKind::Unroll(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::UnstableFeatureBound(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::UnstableRemoved(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::Used { used_by: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::WindowsSubsystem(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                }
            }
        }
    };StableHash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for AttributeKind {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        AttributeKind::AllowInternalUnsafe(ref __binding_0) => {
                            0usize
                        }
                        AttributeKind::AllowInternalUnstable(ref __binding_0,
                            ref __binding_1) => {
                            1usize
                        }
                        AttributeKind::AlwaysGca => { 2usize }
                        AttributeKind::AutomaticallyDerived => { 3usize }
                        AttributeKind::CfgAttrTrace(ref __binding_0) => { 4usize }
                        AttributeKind::CfgTrace(ref __binding_0) => { 5usize }
                        AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
                            {
                            6usize
                        }
                        AttributeKind::Cold => { 7usize }
                        AttributeKind::CollapseDebugInfo(ref __binding_0) => {
                            8usize
                        }
                        AttributeKind::CompilerBuiltins => { 9usize }
                        AttributeKind::ConstContinue(ref __binding_0) => { 10usize }
                        AttributeKind::Coroutine => { 11usize }
                        AttributeKind::Coverage(ref __binding_0) => { 12usize }
                        AttributeKind::CrateName {
                            name: ref __binding_0,
                            name_span: ref __binding_1,
                            attr_span: ref __binding_2 } => {
                            13usize
                        }
                        AttributeKind::CrateType(ref __binding_0) => { 14usize }
                        AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
                            => {
                            15usize
                        }
                        AttributeKind::DebuggerVisualizer(ref __binding_0) => {
                            16usize
                        }
                        AttributeKind::DefaultLibAllocator => { 17usize }
                        AttributeKind::Deprecated {
                            deprecation: ref __binding_0,
                            span: ref __binding_1,
                            is_inner: ref __binding_2 } => {
                            18usize
                        }
                        AttributeKind::DoNotRecommend => { 19usize }
                        AttributeKind::Doc(ref __binding_0) => { 20usize }
                        AttributeKind::DocComment {
                            style: ref __binding_0,
                            kind: ref __binding_1,
                            span: ref __binding_2,
                            comment: ref __binding_3 } => {
                            21usize
                        }
                        AttributeKind::EiiDeclaration(ref __binding_0) => {
                            22usize
                        }
                        AttributeKind::EiiImpl(ref __binding_0) => { 23usize }
                        AttributeKind::ExportName {
                            name: ref __binding_0, span: ref __binding_1 } => {
                            24usize
                        }
                        AttributeKind::ExportStable => { 25usize }
                        AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
                            {
                            26usize
                        }
                        AttributeKind::FfiConst => { 27usize }
                        AttributeKind::FfiPure(ref __binding_0) => { 28usize }
                        AttributeKind::Fundamental => { 29usize }
                        AttributeKind::Ignore {
                            span: ref __binding_0, reason: ref __binding_1 } => {
                            30usize
                        }
                        AttributeKind::Inline(ref __binding_0, ref __binding_1) => {
                            31usize
                        }
                        AttributeKind::InstructionSet(ref __binding_0) => {
                            32usize
                        }
                        AttributeKind::InstrumentFn(ref __binding_0) => { 33usize }
                        AttributeKind::Lang(ref __binding_0) => { 34usize }
                        AttributeKind::Link(ref __binding_0, ref __binding_1) => {
                            35usize
                        }
                        AttributeKind::LinkName {
                            name: ref __binding_0, span: ref __binding_1 } => {
                            36usize
                        }
                        AttributeKind::LinkOrdinal {
                            ordinal: ref __binding_0, span: ref __binding_1 } => {
                            37usize
                        }
                        AttributeKind::LinkSection { name: ref __binding_0 } => {
                            38usize
                        }
                        AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
                            {
                            39usize
                        }
                        AttributeKind::LintAsPtr => { 40usize }
                        AttributeKind::LintCheck(ref __binding_0) => { 41usize }
                        AttributeKind::LintNeverReturnsNullPtr => { 42usize }
                        AttributeKind::LintShouldNotBeCalledOnConstItems => {
                            43usize
                        }
                        AttributeKind::LoopMatch(ref __binding_0) => { 44usize }
                        AttributeKind::MacroEscape => { 45usize }
                        AttributeKind::MacroExport {
                            span: ref __binding_0, local_inner_macros: ref __binding_1 }
                            => {
                            46usize
                        }
                        AttributeKind::MacroUse {
                            span: ref __binding_0, arguments: ref __binding_1 } => {
                            47usize
                        }
                        AttributeKind::Marker => { 48usize }
                        AttributeKind::MayDangle(ref __binding_0) => { 49usize }
                        AttributeKind::MoveSizeLimit { limit: ref __binding_0 } => {
                            50usize
                        }
                        AttributeKind::MustNotSupend { reason: ref __binding_0 } =>
                            {
                            51usize
                        }
                        AttributeKind::MustUse {
                            span: ref __binding_0, reason: ref __binding_1 } => {
                            52usize
                        }
                        AttributeKind::Naked(ref __binding_0) => { 53usize }
                        AttributeKind::NeedsAllocator => { 54usize }
                        AttributeKind::NeedsPanicRuntime => { 55usize }
                        AttributeKind::NoBuiltins => { 56usize }
                        AttributeKind::NoCore => { 57usize }
                        AttributeKind::NoImplicitPrelude => { 58usize }
                        AttributeKind::NoLink => { 59usize }
                        AttributeKind::NoMain => { 60usize }
                        AttributeKind::NoMangle(ref __binding_0) => { 61usize }
                        AttributeKind::NoStd => { 62usize }
                        AttributeKind::NonExhaustive(ref __binding_0) => { 63usize }
                        AttributeKind::OnConst {
                            span: ref __binding_0, directive: ref __binding_1 } => {
                            64usize
                        }
                        AttributeKind::OnMove { directive: ref __binding_0 } => {
                            65usize
                        }
                        AttributeKind::OnTypeError {
                            span: ref __binding_0, directive: ref __binding_1 } => {
                            66usize
                        }
                        AttributeKind::OnUnimplemented { directive: ref __binding_0
                            } => {
                            67usize
                        }
                        AttributeKind::OnUnknown { directive: ref __binding_0 } => {
                            68usize
                        }
                        AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
                            } => {
                            69usize
                        }
                        AttributeKind::Opaque => { 70usize }
                        AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
                            {
                            71usize
                        }
                        AttributeKind::PanicRuntime => { 72usize }
                        AttributeKind::PatchableFunctionEntry {
                            prefix: ref __binding_0,
                            entry: ref __binding_1,
                            section: ref __binding_2 } => {
                            73usize
                        }
                        AttributeKind::Path(ref __binding_0, ref __binding_1) => {
                            74usize
                        }
                        AttributeKind::PatternComplexityLimit {
                            limit: ref __binding_0 } => {
                            75usize
                        }
                        AttributeKind::PinV2(ref __binding_0) => { 76usize }
                        AttributeKind::PreludeImport => { 77usize }
                        AttributeKind::ProcMacro => { 78usize }
                        AttributeKind::ProcMacroAttribute => { 79usize }
                        AttributeKind::ProcMacroDerive {
                            trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
                            => {
                            80usize
                        }
                        AttributeKind::ProfilerRuntime => { 81usize }
                        AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
                            {
                            82usize
                        }
                        AttributeKind::ReexportTestHarnessMain(ref __binding_0) => {
                            83usize
                        }
                        AttributeKind::RegisterTool {
                            attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
                            => {
                            84usize
                        }
                        AttributeKind::Repr {
                            reprs: ref __binding_0, first_span: ref __binding_1 } => {
                            85usize
                        }
                        AttributeKind::RustcAbi {
                            attr_span: ref __binding_0, kind: ref __binding_1 } => {
                            86usize
                        }
                        AttributeKind::RustcAlign {
                            align: ref __binding_0, span: ref __binding_1 } => {
                            87usize
                        }
                        AttributeKind::RustcAllocator => { 88usize }
                        AttributeKind::RustcAllocatorZeroed => { 89usize }
                        AttributeKind::RustcAllocatorZeroedVariant {
                            name: ref __binding_0 } => {
                            90usize
                        }
                        AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
                            ref __binding_1) => {
                            91usize
                        }
                        AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
                            {
                            92usize
                        }
                        AttributeKind::RustcAllowLifetimeDependentSpecialization =>
                            {
                            93usize
                        }
                        AttributeKind::RustcAssertVariance {
                            span: ref __binding_0, kind: ref __binding_1 } => {
                            94usize
                        }
                        AttributeKind::RustcAutodiff(ref __binding_0) => { 95usize }
                        AttributeKind::RustcBodyStability {
                            stability: ref __binding_0, span: ref __binding_1 } => {
                            96usize
                        }
                        AttributeKind::RustcBuiltinMacro {
                            builtin_name: ref __binding_0, helper_attrs: ref __binding_1
                            } => {
                            97usize
                        }
                        AttributeKind::RustcCanonicalSymbol => { 98usize }
                        AttributeKind::RustcCaptureAnalysis => { 99usize }
                        AttributeKind::RustcCguTestAttr(ref __binding_0) => {
                            100usize
                        }
                        AttributeKind::RustcClean(ref __binding_0) => { 101usize }
                        AttributeKind::RustcCoherenceIsCore => { 102usize }
                        AttributeKind::RustcCoinductive => { 103usize }
                        AttributeKind::RustcComptime(ref __binding_0) => {
                            104usize
                        }
                        AttributeKind::RustcConfusables {
                            confusables: ref __binding_0 } => {
                            105usize
                        }
                        AttributeKind::RustcConstStability {
                            stability: ref __binding_0, span: ref __binding_1 } => {
                            106usize
                        }
                        AttributeKind::RustcConstStableIndirect => { 107usize }
                        AttributeKind::RustcConversionSuggestion => { 108usize }
                        AttributeKind::RustcDeallocator => { 109usize }
                        AttributeKind::RustcDelayedBugFromInsideQuery => {
                            110usize
                        }
                        AttributeKind::RustcDenyExplicitImpl => { 111usize }
                        AttributeKind::RustcDeprecatedSafe2024 {
                            suggestion: ref __binding_0 } => {
                            112usize
                        }
                        AttributeKind::RustcDiagnosticItem(ref __binding_0) => {
                            113usize
                        }
                        AttributeKind::RustcDoNotConstCheck => { 114usize }
                        AttributeKind::RustcDocPrimitive(ref __binding_0,
                            ref __binding_1) => {
                            115usize
                        }
                        AttributeKind::RustcDummy => { 116usize }
                        AttributeKind::RustcDumpClauses => { 117usize }
                        AttributeKind::RustcDumpDefParents => { 118usize }
                        AttributeKind::RustcDumpDefPath(ref __binding_0) => {
                            119usize
                        }
                        AttributeKind::RustcDumpGenerics => { 120usize }
                        AttributeKind::RustcDumpHiddenTypeOfOpaques => { 121usize }
                        AttributeKind::RustcDumpInferredOutlives => { 122usize }
                        AttributeKind::RustcDumpItemBounds => { 123usize }
                        AttributeKind::RustcDumpLayout(ref __binding_0) => {
                            124usize
                        }
                        AttributeKind::RustcDumpObjectLifetimeDefaults => {
                            125usize
                        }
                        AttributeKind::RustcDumpSymbolName(ref __binding_0) => {
                            126usize
                        }
                        AttributeKind::RustcDumpUserArgs => { 127usize }
                        AttributeKind::RustcDumpVariances => { 128usize }
                        AttributeKind::RustcDumpVariancesOfOpaques => { 129usize }
                        AttributeKind::RustcDumpVtable(ref __binding_0) => {
                            130usize
                        }
                        AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
                            {
                            131usize
                        }
                        AttributeKind::RustcEffectiveVisibility => { 132usize }
                        AttributeKind::RustcEiiForeignItem => { 133usize }
                        AttributeKind::RustcEvaluateWhereClauses => { 134usize }
                        AttributeKind::RustcHasIncoherentInherentImpls => {
                            135usize
                        }
                        AttributeKind::RustcIfThisChanged(ref __binding_0,
                            ref __binding_1) => {
                            136usize
                        }
                        AttributeKind::RustcInheritOverflowChecks => { 137usize }
                        AttributeKind::RustcInsignificantDtor => { 138usize }
                        AttributeKind::RustcIntrinsic => { 139usize }
                        AttributeKind::RustcIntrinsicConstStableIndirect => {
                            140usize
                        }
                        AttributeKind::RustcLegacyConstGenerics {
                            fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
                            {
                            141usize
                        }
                        AttributeKind::RustcLintOptDenyFieldAccess {
                            lint_message: ref __binding_0 } => {
                            142usize
                        }
                        AttributeKind::RustcLintOptTy => { 143usize }
                        AttributeKind::RustcLintQueryInstability => { 144usize }
                        AttributeKind::RustcLintUntrackedQueryInformation => {
                            145usize
                        }
                        AttributeKind::RustcMacroTransparency(ref __binding_0) => {
                            146usize
                        }
                        AttributeKind::RustcMain => { 147usize }
                        AttributeKind::RustcMir(ref __binding_0) => { 148usize }
                        AttributeKind::RustcMustImplementOneOf {
                            attr_span: ref __binding_0, fn_names: ref __binding_1 } => {
                            149usize
                        }
                        AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
                            => {
                            150usize
                        }
                        AttributeKind::RustcNoImplicitAutorefs => { 151usize }
                        AttributeKind::RustcNoImplicitBounds => { 152usize }
                        AttributeKind::RustcNoMirInline => { 153usize }
                        AttributeKind::RustcNoWritable => { 154usize }
                        AttributeKind::RustcNonConstTraitMethod => { 155usize }
                        AttributeKind::RustcNonnullOptimizationGuaranteed => {
                            156usize
                        }
                        AttributeKind::RustcNounwind => { 157usize }
                        AttributeKind::RustcObjcClass { classname: ref __binding_0 }
                            => {
                            158usize
                        }
                        AttributeKind::RustcObjcSelector { methname: ref __binding_0
                            } => {
                            159usize
                        }
                        AttributeKind::RustcOffloadKernel => { 160usize }
                        AttributeKind::RustcPanicsWhenZero => { 161usize }
                        AttributeKind::RustcParenSugar => { 162usize }
                        AttributeKind::RustcPassByValue => { 163usize }
                        AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
                            => {
                            164usize
                        }
                        AttributeKind::RustcPreserveUbChecks => { 165usize }
                        AttributeKind::RustcProcMacroDecls => { 166usize }
                        AttributeKind::RustcPubTransparent(ref __binding_0) => {
                            167usize
                        }
                        AttributeKind::RustcReallocator => { 168usize }
                        AttributeKind::RustcRegions => { 169usize }
                        AttributeKind::RustcScalableVector {
                            element_count: ref __binding_0 } => {
                            170usize
                        }
                        AttributeKind::RustcShouldNotBeCalledOnConstItems => {
                            171usize
                        }
                        AttributeKind::RustcShowSpans(ref __binding_0) => {
                            172usize
                        }
                        AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
                            => {
                            173usize
                        }
                        AttributeKind::RustcSkipDuringMethodDispatch {
                            array: ref __binding_0, boxed_slice: ref __binding_1 } => {
                            174usize
                        }
                        AttributeKind::RustcSpecializationTrait => { 175usize }
                        AttributeKind::RustcStdInternalSymbol => { 176usize }
                        AttributeKind::RustcStrictCoherence(ref __binding_0) => {
                            177usize
                        }
                        AttributeKind::RustcTestMarker(ref __binding_0) => {
                            178usize
                        }
                        AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
                            179usize
                        }
                        AttributeKind::RustcTrivialFieldReads => { 180usize }
                        AttributeKind::Sanitize {
                            on_set: ref __binding_0,
                            off_set: ref __binding_1,
                            rtsan: ref __binding_2,
                            span: ref __binding_3 } => {
                            181usize
                        }
                        AttributeKind::ShouldPanic { reason: ref __binding_0 } => {
                            182usize
                        }
                        AttributeKind::Splat(ref __binding_0) => { 183usize }
                        AttributeKind::Stability {
                            stability: ref __binding_0, span: ref __binding_1 } => {
                            184usize
                        }
                        AttributeKind::TargetFeature {
                            features: ref __binding_0,
                            attr_span: ref __binding_1,
                            was_forced: ref __binding_2 } => {
                            185usize
                        }
                        AttributeKind::TestRunner(ref __binding_0) => { 186usize }
                        AttributeKind::ThreadLocal => { 187usize }
                        AttributeKind::TrackCaller(ref __binding_0) => { 188usize }
                        AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
                            {
                            189usize
                        }
                        AttributeKind::UncheckedTypeAlias => { 190usize }
                        AttributeKind::Unroll(ref __binding_0) => { 191usize }
                        AttributeKind::UnstableFeatureBound(ref __binding_0) => {
                            192usize
                        }
                        AttributeKind::UnstableRemoved(ref __binding_0) => {
                            193usize
                        }
                        AttributeKind::Used { used_by: ref __binding_0 } => {
                            194usize
                        }
                        AttributeKind::WindowsSubsystem(ref __binding_0) => {
                            195usize
                        }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    AttributeKind::AllowInternalUnsafe(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::AllowInternalUnstable(ref __binding_0,
                        ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::AlwaysGca => {}
                    AttributeKind::AutomaticallyDerived => {}
                    AttributeKind::CfgAttrTrace(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::CfgTrace(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Cold => {}
                    AttributeKind::CollapseDebugInfo(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::CompilerBuiltins => {}
                    AttributeKind::ConstContinue(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Coroutine => {}
                    AttributeKind::Coverage(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::CrateName {
                        name: ref __binding_0,
                        name_span: ref __binding_1,
                        attr_span: ref __binding_2 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                    }
                    AttributeKind::CrateType(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::DebuggerVisualizer(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::DefaultLibAllocator => {}
                    AttributeKind::Deprecated {
                        deprecation: ref __binding_0,
                        span: ref __binding_1,
                        is_inner: ref __binding_2 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                    }
                    AttributeKind::DoNotRecommend => {}
                    AttributeKind::Doc(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::DocComment {
                        style: ref __binding_0,
                        kind: ref __binding_1,
                        span: ref __binding_2,
                        comment: ref __binding_3 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                            __encoder);
                    }
                    AttributeKind::EiiDeclaration(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::EiiImpl(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::ExportName {
                        name: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::ExportStable => {}
                    AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::FfiConst => {}
                    AttributeKind::FfiPure(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Fundamental => {}
                    AttributeKind::Ignore {
                        span: ref __binding_0, reason: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::Inline(ref __binding_0, ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::InstructionSet(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::InstrumentFn(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Lang(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Link(ref __binding_0, ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::LinkName {
                        name: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::LinkOrdinal {
                        ordinal: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::LinkSection { name: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::LintAsPtr => {}
                    AttributeKind::LintCheck(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::LintNeverReturnsNullPtr => {}
                    AttributeKind::LintShouldNotBeCalledOnConstItems => {}
                    AttributeKind::LoopMatch(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::MacroEscape => {}
                    AttributeKind::MacroExport {
                        span: ref __binding_0, local_inner_macros: ref __binding_1 }
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::MacroUse {
                        span: ref __binding_0, arguments: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::Marker => {}
                    AttributeKind::MayDangle(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::MoveSizeLimit { limit: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::MustNotSupend { reason: ref __binding_0 } =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::MustUse {
                        span: ref __binding_0, reason: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::Naked(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::NeedsAllocator => {}
                    AttributeKind::NeedsPanicRuntime => {}
                    AttributeKind::NoBuiltins => {}
                    AttributeKind::NoCore => {}
                    AttributeKind::NoImplicitPrelude => {}
                    AttributeKind::NoLink => {}
                    AttributeKind::NoMain => {}
                    AttributeKind::NoMangle(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::NoStd => {}
                    AttributeKind::NonExhaustive(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::OnConst {
                        span: ref __binding_0, directive: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::OnMove { directive: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::OnTypeError {
                        span: ref __binding_0, directive: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::OnUnimplemented { directive: ref __binding_0
                        } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::OnUnknown { directive: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
                        } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Opaque => {}
                    AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::PanicRuntime => {}
                    AttributeKind::PatchableFunctionEntry {
                        prefix: ref __binding_0,
                        entry: ref __binding_1,
                        section: ref __binding_2 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                    }
                    AttributeKind::Path(ref __binding_0, ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::PatternComplexityLimit {
                        limit: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::PinV2(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::PreludeImport => {}
                    AttributeKind::ProcMacro => {}
                    AttributeKind::ProcMacroAttribute => {}
                    AttributeKind::ProcMacroDerive {
                        trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::ProfilerRuntime => {}
                    AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::ReexportTestHarnessMain(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RegisterTool {
                        attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::Repr {
                        reprs: ref __binding_0, first_span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcAbi {
                        attr_span: ref __binding_0, kind: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcAlign {
                        align: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcAllocator => {}
                    AttributeKind::RustcAllocatorZeroed => {}
                    AttributeKind::RustcAllocatorZeroedVariant {
                        name: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
                        ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcAllowLifetimeDependentSpecialization =>
                        {}
                    AttributeKind::RustcAssertVariance {
                        span: ref __binding_0, kind: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcAutodiff(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcBodyStability {
                        stability: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcBuiltinMacro {
                        builtin_name: ref __binding_0, helper_attrs: ref __binding_1
                        } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcCanonicalSymbol => {}
                    AttributeKind::RustcCaptureAnalysis => {}
                    AttributeKind::RustcCguTestAttr(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcClean(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcCoherenceIsCore => {}
                    AttributeKind::RustcCoinductive => {}
                    AttributeKind::RustcComptime(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcConfusables {
                        confusables: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcConstStability {
                        stability: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcConstStableIndirect => {}
                    AttributeKind::RustcConversionSuggestion => {}
                    AttributeKind::RustcDeallocator => {}
                    AttributeKind::RustcDelayedBugFromInsideQuery => {}
                    AttributeKind::RustcDenyExplicitImpl => {}
                    AttributeKind::RustcDeprecatedSafe2024 {
                        suggestion: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcDiagnosticItem(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcDoNotConstCheck => {}
                    AttributeKind::RustcDocPrimitive(ref __binding_0,
                        ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcDummy => {}
                    AttributeKind::RustcDumpClauses => {}
                    AttributeKind::RustcDumpDefParents => {}
                    AttributeKind::RustcDumpDefPath(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcDumpGenerics => {}
                    AttributeKind::RustcDumpHiddenTypeOfOpaques => {}
                    AttributeKind::RustcDumpInferredOutlives => {}
                    AttributeKind::RustcDumpItemBounds => {}
                    AttributeKind::RustcDumpLayout(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcDumpObjectLifetimeDefaults => {}
                    AttributeKind::RustcDumpSymbolName(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcDumpUserArgs => {}
                    AttributeKind::RustcDumpVariances => {}
                    AttributeKind::RustcDumpVariancesOfOpaques => {}
                    AttributeKind::RustcDumpVtable(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcEffectiveVisibility => {}
                    AttributeKind::RustcEiiForeignItem => {}
                    AttributeKind::RustcEvaluateWhereClauses => {}
                    AttributeKind::RustcHasIncoherentInherentImpls => {}
                    AttributeKind::RustcIfThisChanged(ref __binding_0,
                        ref __binding_1) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcInheritOverflowChecks => {}
                    AttributeKind::RustcInsignificantDtor => {}
                    AttributeKind::RustcIntrinsic => {}
                    AttributeKind::RustcIntrinsicConstStableIndirect => {}
                    AttributeKind::RustcLegacyConstGenerics {
                        fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcLintOptDenyFieldAccess {
                        lint_message: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcLintOptTy => {}
                    AttributeKind::RustcLintQueryInstability => {}
                    AttributeKind::RustcLintUntrackedQueryInformation => {}
                    AttributeKind::RustcMacroTransparency(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcMain => {}
                    AttributeKind::RustcMir(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcMustImplementOneOf {
                        attr_span: ref __binding_0, fn_names: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcNoImplicitAutorefs => {}
                    AttributeKind::RustcNoImplicitBounds => {}
                    AttributeKind::RustcNoMirInline => {}
                    AttributeKind::RustcNoWritable => {}
                    AttributeKind::RustcNonConstTraitMethod => {}
                    AttributeKind::RustcNonnullOptimizationGuaranteed => {}
                    AttributeKind::RustcNounwind => {}
                    AttributeKind::RustcObjcClass { classname: ref __binding_0 }
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcObjcSelector { methname: ref __binding_0
                        } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcOffloadKernel => {}
                    AttributeKind::RustcPanicsWhenZero => {}
                    AttributeKind::RustcParenSugar => {}
                    AttributeKind::RustcPassByValue => {}
                    AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcPreserveUbChecks => {}
                    AttributeKind::RustcProcMacroDecls => {}
                    AttributeKind::RustcPubTransparent(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcReallocator => {}
                    AttributeKind::RustcRegions => {}
                    AttributeKind::RustcScalableVector {
                        element_count: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcShouldNotBeCalledOnConstItems => {}
                    AttributeKind::RustcShowSpans(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
                        => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcSkipDuringMethodDispatch {
                        array: ref __binding_0, boxed_slice: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::RustcSpecializationTrait => {}
                    AttributeKind::RustcStdInternalSymbol => {}
                    AttributeKind::RustcStrictCoherence(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcTestMarker(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::RustcTrivialFieldReads => {}
                    AttributeKind::Sanitize {
                        on_set: ref __binding_0,
                        off_set: ref __binding_1,
                        rtsan: ref __binding_2,
                        span: ref __binding_3 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                            __encoder);
                    }
                    AttributeKind::ShouldPanic { reason: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Splat(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Stability {
                        stability: ref __binding_0, span: ref __binding_1 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                    }
                    AttributeKind::TargetFeature {
                        features: ref __binding_0,
                        attr_span: ref __binding_1,
                        was_forced: ref __binding_2 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                            __encoder);
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                            __encoder);
                    }
                    AttributeKind::TestRunner(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::ThreadLocal => {}
                    AttributeKind::TrackCaller(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
                        {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::UncheckedTypeAlias => {}
                    AttributeKind::Unroll(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::UnstableFeatureBound(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::UnstableRemoved(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::Used { used_by: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    AttributeKind::WindowsSubsystem(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for AttributeKind {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        AttributeKind::AllowInternalUnsafe(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => {
                        AttributeKind::AllowInternalUnstable(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    2usize => { AttributeKind::AlwaysGca }
                    3usize => { AttributeKind::AutomaticallyDerived }
                    4usize => {
                        AttributeKind::CfgAttrTrace(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    5usize => {
                        AttributeKind::CfgTrace(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    6usize => {
                        AttributeKind::CfiEncoding {
                            encoding: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    7usize => { AttributeKind::Cold }
                    8usize => {
                        AttributeKind::CollapseDebugInfo(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    9usize => { AttributeKind::CompilerBuiltins }
                    10usize => {
                        AttributeKind::ConstContinue(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    11usize => { AttributeKind::Coroutine }
                    12usize => {
                        AttributeKind::Coverage(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    13usize => {
                        AttributeKind::CrateName {
                            name: ::rustc_serialize::Decodable::decode(__decoder),
                            name_span: ::rustc_serialize::Decodable::decode(__decoder),
                            attr_span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    14usize => {
                        AttributeKind::CrateType(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    15usize => {
                        AttributeKind::CustomMir(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    16usize => {
                        AttributeKind::DebuggerVisualizer(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    17usize => { AttributeKind::DefaultLibAllocator }
                    18usize => {
                        AttributeKind::Deprecated {
                            deprecation: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            is_inner: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    19usize => { AttributeKind::DoNotRecommend }
                    20usize => {
                        AttributeKind::Doc(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    21usize => {
                        AttributeKind::DocComment {
                            style: ::rustc_serialize::Decodable::decode(__decoder),
                            kind: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            comment: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    22usize => {
                        AttributeKind::EiiDeclaration(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    23usize => {
                        AttributeKind::EiiImpl(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    24usize => {
                        AttributeKind::ExportName {
                            name: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    25usize => { AttributeKind::ExportStable }
                    26usize => {
                        AttributeKind::Feature(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    27usize => { AttributeKind::FfiConst }
                    28usize => {
                        AttributeKind::FfiPure(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    29usize => { AttributeKind::Fundamental }
                    30usize => {
                        AttributeKind::Ignore {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            reason: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    31usize => {
                        AttributeKind::Inline(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    32usize => {
                        AttributeKind::InstructionSet(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    33usize => {
                        AttributeKind::InstrumentFn(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    34usize => {
                        AttributeKind::Lang(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    35usize => {
                        AttributeKind::Link(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    36usize => {
                        AttributeKind::LinkName {
                            name: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    37usize => {
                        AttributeKind::LinkOrdinal {
                            ordinal: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    38usize => {
                        AttributeKind::LinkSection {
                            name: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    39usize => {
                        AttributeKind::Linkage(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    40usize => { AttributeKind::LintAsPtr }
                    41usize => {
                        AttributeKind::LintCheck(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    42usize => { AttributeKind::LintNeverReturnsNullPtr }
                    43usize => {
                        AttributeKind::LintShouldNotBeCalledOnConstItems
                    }
                    44usize => {
                        AttributeKind::LoopMatch(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    45usize => { AttributeKind::MacroEscape }
                    46usize => {
                        AttributeKind::MacroExport {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            local_inner_macros: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    47usize => {
                        AttributeKind::MacroUse {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            arguments: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    48usize => { AttributeKind::Marker }
                    49usize => {
                        AttributeKind::MayDangle(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    50usize => {
                        AttributeKind::MoveSizeLimit {
                            limit: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    51usize => {
                        AttributeKind::MustNotSupend {
                            reason: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    52usize => {
                        AttributeKind::MustUse {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            reason: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    53usize => {
                        AttributeKind::Naked(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    54usize => { AttributeKind::NeedsAllocator }
                    55usize => { AttributeKind::NeedsPanicRuntime }
                    56usize => { AttributeKind::NoBuiltins }
                    57usize => { AttributeKind::NoCore }
                    58usize => { AttributeKind::NoImplicitPrelude }
                    59usize => { AttributeKind::NoLink }
                    60usize => { AttributeKind::NoMain }
                    61usize => {
                        AttributeKind::NoMangle(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    62usize => { AttributeKind::NoStd }
                    63usize => {
                        AttributeKind::NonExhaustive(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    64usize => {
                        AttributeKind::OnConst {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            directive: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    65usize => {
                        AttributeKind::OnMove {
                            directive: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    66usize => {
                        AttributeKind::OnTypeError {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            directive: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    67usize => {
                        AttributeKind::OnUnimplemented {
                            directive: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    68usize => {
                        AttributeKind::OnUnknown {
                            directive: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    69usize => {
                        AttributeKind::OnUnmatchedArgs {
                            directive: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    70usize => { AttributeKind::Opaque }
                    71usize => {
                        AttributeKind::Optimize(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    72usize => { AttributeKind::PanicRuntime }
                    73usize => {
                        AttributeKind::PatchableFunctionEntry {
                            prefix: ::rustc_serialize::Decodable::decode(__decoder),
                            entry: ::rustc_serialize::Decodable::decode(__decoder),
                            section: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    74usize => {
                        AttributeKind::Path(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    75usize => {
                        AttributeKind::PatternComplexityLimit {
                            limit: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    76usize => {
                        AttributeKind::PinV2(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    77usize => { AttributeKind::PreludeImport }
                    78usize => { AttributeKind::ProcMacro }
                    79usize => { AttributeKind::ProcMacroAttribute }
                    80usize => {
                        AttributeKind::ProcMacroDerive {
                            trait_name: ::rustc_serialize::Decodable::decode(__decoder),
                            helper_attrs: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    81usize => { AttributeKind::ProfilerRuntime }
                    82usize => {
                        AttributeKind::RecursionLimit {
                            limit: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    83usize => {
                        AttributeKind::ReexportTestHarnessMain(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    84usize => {
                        AttributeKind::RegisterTool {
                            attr_tools: ::rustc_serialize::Decodable::decode(__decoder),
                            lint_tools: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    85usize => {
                        AttributeKind::Repr {
                            reprs: ::rustc_serialize::Decodable::decode(__decoder),
                            first_span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    86usize => {
                        AttributeKind::RustcAbi {
                            attr_span: ::rustc_serialize::Decodable::decode(__decoder),
                            kind: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    87usize => {
                        AttributeKind::RustcAlign {
                            align: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    88usize => { AttributeKind::RustcAllocator }
                    89usize => { AttributeKind::RustcAllocatorZeroed }
                    90usize => {
                        AttributeKind::RustcAllocatorZeroedVariant {
                            name: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    91usize => {
                        AttributeKind::RustcAllowConstFnUnstable(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    92usize => {
                        AttributeKind::RustcAllowIncoherentImpl(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    93usize => {
                        AttributeKind::RustcAllowLifetimeDependentSpecialization
                    }
                    94usize => {
                        AttributeKind::RustcAssertVariance {
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                            kind: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    95usize => {
                        AttributeKind::RustcAutodiff(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    96usize => {
                        AttributeKind::RustcBodyStability {
                            stability: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    97usize => {
                        AttributeKind::RustcBuiltinMacro {
                            builtin_name: ::rustc_serialize::Decodable::decode(__decoder),
                            helper_attrs: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    98usize => { AttributeKind::RustcCanonicalSymbol }
                    99usize => { AttributeKind::RustcCaptureAnalysis }
                    100usize => {
                        AttributeKind::RustcCguTestAttr(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    101usize => {
                        AttributeKind::RustcClean(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    102usize => { AttributeKind::RustcCoherenceIsCore }
                    103usize => { AttributeKind::RustcCoinductive }
                    104usize => {
                        AttributeKind::RustcComptime(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    105usize => {
                        AttributeKind::RustcConfusables {
                            confusables: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    106usize => {
                        AttributeKind::RustcConstStability {
                            stability: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    107usize => { AttributeKind::RustcConstStableIndirect }
                    108usize => { AttributeKind::RustcConversionSuggestion }
                    109usize => { AttributeKind::RustcDeallocator }
                    110usize => {
                        AttributeKind::RustcDelayedBugFromInsideQuery
                    }
                    111usize => { AttributeKind::RustcDenyExplicitImpl }
                    112usize => {
                        AttributeKind::RustcDeprecatedSafe2024 {
                            suggestion: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    113usize => {
                        AttributeKind::RustcDiagnosticItem(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    114usize => { AttributeKind::RustcDoNotConstCheck }
                    115usize => {
                        AttributeKind::RustcDocPrimitive(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    116usize => { AttributeKind::RustcDummy }
                    117usize => { AttributeKind::RustcDumpClauses }
                    118usize => { AttributeKind::RustcDumpDefParents }
                    119usize => {
                        AttributeKind::RustcDumpDefPath(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    120usize => { AttributeKind::RustcDumpGenerics }
                    121usize => { AttributeKind::RustcDumpHiddenTypeOfOpaques }
                    122usize => { AttributeKind::RustcDumpInferredOutlives }
                    123usize => { AttributeKind::RustcDumpItemBounds }
                    124usize => {
                        AttributeKind::RustcDumpLayout(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    125usize => {
                        AttributeKind::RustcDumpObjectLifetimeDefaults
                    }
                    126usize => {
                        AttributeKind::RustcDumpSymbolName(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    127usize => { AttributeKind::RustcDumpUserArgs }
                    128usize => { AttributeKind::RustcDumpVariances }
                    129usize => { AttributeKind::RustcDumpVariancesOfOpaques }
                    130usize => {
                        AttributeKind::RustcDumpVtable(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    131usize => {
                        AttributeKind::RustcDynIncompatibleTrait(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    132usize => { AttributeKind::RustcEffectiveVisibility }
                    133usize => { AttributeKind::RustcEiiForeignItem }
                    134usize => { AttributeKind::RustcEvaluateWhereClauses }
                    135usize => {
                        AttributeKind::RustcHasIncoherentInherentImpls
                    }
                    136usize => {
                        AttributeKind::RustcIfThisChanged(::rustc_serialize::Decodable::decode(__decoder),
                            ::rustc_serialize::Decodable::decode(__decoder))
                    }
                    137usize => { AttributeKind::RustcInheritOverflowChecks }
                    138usize => { AttributeKind::RustcInsignificantDtor }
                    139usize => { AttributeKind::RustcIntrinsic }
                    140usize => {
                        AttributeKind::RustcIntrinsicConstStableIndirect
                    }
                    141usize => {
                        AttributeKind::RustcLegacyConstGenerics {
                            fn_indexes: ::rustc_serialize::Decodable::decode(__decoder),
                            attr_span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    142usize => {
                        AttributeKind::RustcLintOptDenyFieldAccess {
                            lint_message: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    143usize => { AttributeKind::RustcLintOptTy }
                    144usize => { AttributeKind::RustcLintQueryInstability }
                    145usize => {
                        AttributeKind::RustcLintUntrackedQueryInformation
                    }
                    146usize => {
                        AttributeKind::RustcMacroTransparency(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    147usize => { AttributeKind::RustcMain }
                    148usize => {
                        AttributeKind::RustcMir(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    149usize => {
                        AttributeKind::RustcMustImplementOneOf {
                            attr_span: ::rustc_serialize::Decodable::decode(__decoder),
                            fn_names: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    150usize => {
                        AttributeKind::RustcMustMatchExhaustively(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    151usize => { AttributeKind::RustcNoImplicitAutorefs }
                    152usize => { AttributeKind::RustcNoImplicitBounds }
                    153usize => { AttributeKind::RustcNoMirInline }
                    154usize => { AttributeKind::RustcNoWritable }
                    155usize => { AttributeKind::RustcNonConstTraitMethod }
                    156usize => {
                        AttributeKind::RustcNonnullOptimizationGuaranteed
                    }
                    157usize => { AttributeKind::RustcNounwind }
                    158usize => {
                        AttributeKind::RustcObjcClass {
                            classname: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    159usize => {
                        AttributeKind::RustcObjcSelector {
                            methname: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    160usize => { AttributeKind::RustcOffloadKernel }
                    161usize => { AttributeKind::RustcPanicsWhenZero }
                    162usize => { AttributeKind::RustcParenSugar }
                    163usize => { AttributeKind::RustcPassByValue }
                    164usize => {
                        AttributeKind::RustcPassIndirectlyInNonRusticAbis(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    165usize => { AttributeKind::RustcPreserveUbChecks }
                    166usize => { AttributeKind::RustcProcMacroDecls }
                    167usize => {
                        AttributeKind::RustcPubTransparent(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    168usize => { AttributeKind::RustcReallocator }
                    169usize => { AttributeKind::RustcRegions }
                    170usize => {
                        AttributeKind::RustcScalableVector {
                            element_count: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    171usize => {
                        AttributeKind::RustcShouldNotBeCalledOnConstItems
                    }
                    172usize => {
                        AttributeKind::RustcShowSpans(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    173usize => {
                        AttributeKind::RustcSimdMonomorphizeLaneLimit(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    174usize => {
                        AttributeKind::RustcSkipDuringMethodDispatch {
                            array: ::rustc_serialize::Decodable::decode(__decoder),
                            boxed_slice: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    175usize => { AttributeKind::RustcSpecializationTrait }
                    176usize => { AttributeKind::RustcStdInternalSymbol }
                    177usize => {
                        AttributeKind::RustcStrictCoherence(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    178usize => {
                        AttributeKind::RustcTestMarker(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    179usize => {
                        AttributeKind::RustcThenThisWouldNeed(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    180usize => { AttributeKind::RustcTrivialFieldReads }
                    181usize => {
                        AttributeKind::Sanitize {
                            on_set: ::rustc_serialize::Decodable::decode(__decoder),
                            off_set: ::rustc_serialize::Decodable::decode(__decoder),
                            rtsan: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    182usize => {
                        AttributeKind::ShouldPanic {
                            reason: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    183usize => {
                        AttributeKind::Splat(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    184usize => {
                        AttributeKind::Stability {
                            stability: ::rustc_serialize::Decodable::decode(__decoder),
                            span: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    185usize => {
                        AttributeKind::TargetFeature {
                            features: ::rustc_serialize::Decodable::decode(__decoder),
                            attr_span: ::rustc_serialize::Decodable::decode(__decoder),
                            was_forced: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    186usize => {
                        AttributeKind::TestRunner(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    187usize => { AttributeKind::ThreadLocal }
                    188usize => {
                        AttributeKind::TrackCaller(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    189usize => {
                        AttributeKind::TypeLengthLimit {
                            limit: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    190usize => { AttributeKind::UncheckedTypeAlias }
                    191usize => {
                        AttributeKind::Unroll(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    192usize => {
                        AttributeKind::UnstableFeatureBound(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    193usize => {
                        AttributeKind::UnstableRemoved(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    194usize => {
                        AttributeKind::Used {
                            used_by: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    195usize => {
                        AttributeKind::WindowsSubsystem(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `AttributeKind`, expected 0..196, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable, const _: () =
    {
        #[allow(unused)]
        impl PrintAttribute for AttributeKind {
            fn should_render(&self) -> bool { true }
            fn print_attribute(&self,
                __p: &mut rustc_ast_pretty::pp::Printer) {
                match self {
                    Self::AllowInternalUnsafe(f0) => {
                        __p.word("AllowInternalUnsafe");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::AllowInternalUnstable(f0, f1) => {
                        __p.word("AllowInternalUnstable");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::AlwaysGca => { __p.word("AlwaysGca") }
                    Self::AutomaticallyDerived => {
                        __p.word("AutomaticallyDerived")
                    }
                    Self::CfgAttrTrace(f0) => {
                        __p.word("CfgAttrTrace");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::CfgTrace(f0) => {
                        __p.word("CfgTrace");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::CfiEncoding { encoding } => {
                        __p.word("CfiEncoding");
                        if true && !encoding.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if encoding.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("encoding");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        encoding.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Cold => { __p.word("Cold") }
                    Self::CollapseDebugInfo(f0) => {
                        __p.word("CollapseDebugInfo");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::CompilerBuiltins => { __p.word("CompilerBuiltins") }
                    Self::ConstContinue(f0) => {
                        __p.word("ConstContinue");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Coroutine => { __p.word("Coroutine") }
                    Self::Coverage(f0) => {
                        __p.word("Coverage");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::CrateName { name, name_span, attr_span } => {
                        __p.word("CrateName");
                        if true && !name.should_render() &&
                                    !name_span.should_render() && !attr_span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        name.print_attribute(__p);
                        if name_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("name_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        name_span.print_attribute(__p);
                        if attr_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::CrateType(f0) => {
                        __p.word("CrateType");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::CustomMir(f0, f1) => {
                        __p.word("CustomMir");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::DebuggerVisualizer(f0) => {
                        __p.word("DebuggerVisualizer");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::DefaultLibAllocator => {
                        __p.word("DefaultLibAllocator")
                    }
                    Self::Deprecated { deprecation, span, is_inner } => {
                        __p.word("Deprecated");
                        if true && !deprecation.should_render() &&
                                    !span.should_render() && !is_inner.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if deprecation.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("deprecation");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        deprecation.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if is_inner.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("is_inner");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        is_inner.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::DoNotRecommend => { __p.word("DoNotRecommend") }
                    Self::Doc(f0) => {
                        __p.word("Doc");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::DocComment { style, kind, span, comment } => {
                        __p.word("DocComment");
                        if true && !style.should_render() && !kind.should_render()
                                    && !span.should_render() && !comment.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if style.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("style");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        style.print_attribute(__p);
                        if kind.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("kind");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        kind.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if comment.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("comment");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        comment.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::EiiDeclaration(f0) => {
                        __p.word("EiiDeclaration");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::EiiImpl(f0) => {
                        __p.word("EiiImpl");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::ExportName { name, span } => {
                        __p.word("ExportName");
                        if true && !name.should_render() && !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        name.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::ExportStable => { __p.word("ExportStable") }
                    Self::Feature(f0, f1) => {
                        __p.word("Feature");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::FfiConst => { __p.word("FfiConst") }
                    Self::FfiPure(f0) => {
                        __p.word("FfiPure");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Fundamental => { __p.word("Fundamental") }
                    Self::Ignore { span, reason } => {
                        __p.word("Ignore");
                        if true && !span.should_render() && !reason.should_render()
                            {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if reason.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("reason");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        reason.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Inline(f0, f1) => {
                        __p.word("Inline");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::InstructionSet(f0) => {
                        __p.word("InstructionSet");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::InstrumentFn(f0) => {
                        __p.word("InstrumentFn");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Lang(f0) => {
                        __p.word("Lang");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Link(f0, f1) => {
                        __p.word("Link");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::LinkName { name, span } => {
                        __p.word("LinkName");
                        if true && !name.should_render() && !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        name.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::LinkOrdinal { ordinal, span } => {
                        __p.word("LinkOrdinal");
                        if true && !ordinal.should_render() && !span.should_render()
                            {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if ordinal.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("ordinal");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        ordinal.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::LinkSection { name } => {
                        __p.word("LinkSection");
                        if true && !name.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        name.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Linkage(f0, f1) => {
                        __p.word("Linkage");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::LintAsPtr => { __p.word("LintAsPtr") }
                    Self::LintCheck(f0) => {
                        __p.word("LintCheck");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::LintNeverReturnsNullPtr => {
                        __p.word("LintNeverReturnsNullPtr")
                    }
                    Self::LintShouldNotBeCalledOnConstItems => {
                        __p.word("LintShouldNotBeCalledOnConstItems")
                    }
                    Self::LoopMatch(f0) => {
                        __p.word("LoopMatch");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::MacroEscape => { __p.word("MacroEscape") }
                    Self::MacroExport { span, local_inner_macros } => {
                        __p.word("MacroExport");
                        if true && !span.should_render() &&
                                !local_inner_macros.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if local_inner_macros.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("local_inner_macros");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        local_inner_macros.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::MacroUse { span, arguments } => {
                        __p.word("MacroUse");
                        if true && !span.should_render() &&
                                !arguments.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if arguments.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("arguments");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        arguments.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Marker => { __p.word("Marker") }
                    Self::MayDangle(f0) => {
                        __p.word("MayDangle");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::MoveSizeLimit { limit } => {
                        __p.word("MoveSizeLimit");
                        if true && !limit.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if limit.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("limit");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        limit.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::MustNotSupend { reason } => {
                        __p.word("MustNotSupend");
                        if true && !reason.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if reason.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("reason");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        reason.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::MustUse { span, reason } => {
                        __p.word("MustUse");
                        if true && !span.should_render() && !reason.should_render()
                            {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if reason.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("reason");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        reason.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Naked(f0) => {
                        __p.word("Naked");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::NeedsAllocator => { __p.word("NeedsAllocator") }
                    Self::NeedsPanicRuntime => { __p.word("NeedsPanicRuntime") }
                    Self::NoBuiltins => { __p.word("NoBuiltins") }
                    Self::NoCore => { __p.word("NoCore") }
                    Self::NoImplicitPrelude => { __p.word("NoImplicitPrelude") }
                    Self::NoLink => { __p.word("NoLink") }
                    Self::NoMain => { __p.word("NoMain") }
                    Self::NoMangle(f0) => {
                        __p.word("NoMangle");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::NoStd => { __p.word("NoStd") }
                    Self::NonExhaustive(f0) => {
                        __p.word("NonExhaustive");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::OnConst { span, directive } => {
                        __p.word("OnConst");
                        if true && !span.should_render() &&
                                !directive.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if directive.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("directive");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        directive.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::OnMove { directive } => {
                        __p.word("OnMove");
                        if true && !directive.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if directive.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("directive");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        directive.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::OnTypeError { span, directive } => {
                        __p.word("OnTypeError");
                        if true && !span.should_render() &&
                                !directive.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if directive.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("directive");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        directive.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::OnUnimplemented { directive } => {
                        __p.word("OnUnimplemented");
                        if true && !directive.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if directive.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("directive");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        directive.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::OnUnknown { directive } => {
                        __p.word("OnUnknown");
                        if true && !directive.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if directive.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("directive");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        directive.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::OnUnmatchedArgs { directive } => {
                        __p.word("OnUnmatchedArgs");
                        if true && !directive.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if directive.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("directive");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        directive.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Opaque => { __p.word("Opaque") }
                    Self::Optimize(f0, f1) => {
                        __p.word("Optimize");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::PanicRuntime => { __p.word("PanicRuntime") }
                    Self::PatchableFunctionEntry { prefix, entry, section } => {
                        __p.word("PatchableFunctionEntry");
                        if true && !prefix.should_render() && !entry.should_render()
                                && !section.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if prefix.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("prefix");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        prefix.print_attribute(__p);
                        if entry.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("entry");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        entry.print_attribute(__p);
                        if section.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("section");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        section.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Path(f0, f1) => {
                        __p.word("Path");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::PatternComplexityLimit { limit } => {
                        __p.word("PatternComplexityLimit");
                        if true && !limit.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if limit.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("limit");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        limit.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::PinV2(f0) => {
                        __p.word("PinV2");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::PreludeImport => { __p.word("PreludeImport") }
                    Self::ProcMacro => { __p.word("ProcMacro") }
                    Self::ProcMacroAttribute => {
                        __p.word("ProcMacroAttribute")
                    }
                    Self::ProcMacroDerive { trait_name, helper_attrs } => {
                        __p.word("ProcMacroDerive");
                        if true && !trait_name.should_render() &&
                                !helper_attrs.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if trait_name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("trait_name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        trait_name.print_attribute(__p);
                        if helper_attrs.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("helper_attrs");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        helper_attrs.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::ProfilerRuntime => { __p.word("ProfilerRuntime") }
                    Self::RecursionLimit { limit } => {
                        __p.word("RecursionLimit");
                        if true && !limit.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if limit.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("limit");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        limit.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::ReexportTestHarnessMain(f0) => {
                        __p.word("ReexportTestHarnessMain");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RegisterTool { attr_tools, lint_tools } => {
                        __p.word("RegisterTool");
                        if true && !attr_tools.should_render() &&
                                !lint_tools.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if attr_tools.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_tools");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_tools.print_attribute(__p);
                        if lint_tools.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("lint_tools");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        lint_tools.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Repr { reprs, first_span } => {
                        __p.word("Repr");
                        if true && !reprs.should_render() &&
                                !first_span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if reprs.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("reprs");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        reprs.print_attribute(__p);
                        if first_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("first_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        first_span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcAbi { attr_span, kind } => {
                        __p.word("RustcAbi");
                        if true && !attr_span.should_render() &&
                                !kind.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if attr_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_span.print_attribute(__p);
                        if kind.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("kind");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        kind.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcAlign { align, span } => {
                        __p.word("RustcAlign");
                        if true && !align.should_render() && !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if align.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("align");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        align.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcAllocator => { __p.word("RustcAllocator") }
                    Self::RustcAllocatorZeroed => {
                        __p.word("RustcAllocatorZeroed")
                    }
                    Self::RustcAllocatorZeroedVariant { name } => {
                        __p.word("RustcAllocatorZeroedVariant");
                        if true && !name.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        name.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcAllowConstFnUnstable(f0, f1) => {
                        __p.word("RustcAllowConstFnUnstable");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcAllowIncoherentImpl(f0) => {
                        __p.word("RustcAllowIncoherentImpl");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcAllowLifetimeDependentSpecialization => {
                        __p.word("RustcAllowLifetimeDependentSpecialization")
                    }
                    Self::RustcAssertVariance { span, kind } => {
                        __p.word("RustcAssertVariance");
                        if true && !span.should_render() && !kind.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        if kind.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("kind");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        kind.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcAutodiff(f0) => {
                        __p.word("RustcAutodiff");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcBodyStability { stability, span } => {
                        __p.word("RustcBodyStability");
                        if true && !stability.should_render() &&
                                !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if stability.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("stability");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        stability.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcBuiltinMacro { builtin_name, helper_attrs } => {
                        __p.word("RustcBuiltinMacro");
                        if true && !builtin_name.should_render() &&
                                !helper_attrs.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if builtin_name.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("builtin_name");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        builtin_name.print_attribute(__p);
                        if helper_attrs.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("helper_attrs");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        helper_attrs.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcCanonicalSymbol => {
                        __p.word("RustcCanonicalSymbol")
                    }
                    Self::RustcCaptureAnalysis => {
                        __p.word("RustcCaptureAnalysis")
                    }
                    Self::RustcCguTestAttr(f0) => {
                        __p.word("RustcCguTestAttr");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcClean(f0) => {
                        __p.word("RustcClean");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcCoherenceIsCore => {
                        __p.word("RustcCoherenceIsCore")
                    }
                    Self::RustcCoinductive => { __p.word("RustcCoinductive") }
                    Self::RustcComptime(f0) => {
                        __p.word("RustcComptime");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcConfusables { confusables } => {
                        __p.word("RustcConfusables");
                        if true && !confusables.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if confusables.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("confusables");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        confusables.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcConstStability { stability, span } => {
                        __p.word("RustcConstStability");
                        if true && !stability.should_render() &&
                                !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if stability.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("stability");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        stability.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcConstStableIndirect => {
                        __p.word("RustcConstStableIndirect")
                    }
                    Self::RustcConversionSuggestion => {
                        __p.word("RustcConversionSuggestion")
                    }
                    Self::RustcDeallocator => { __p.word("RustcDeallocator") }
                    Self::RustcDelayedBugFromInsideQuery => {
                        __p.word("RustcDelayedBugFromInsideQuery")
                    }
                    Self::RustcDenyExplicitImpl => {
                        __p.word("RustcDenyExplicitImpl")
                    }
                    Self::RustcDeprecatedSafe2024 { suggestion } => {
                        __p.word("RustcDeprecatedSafe2024");
                        if true && !suggestion.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if suggestion.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("suggestion");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        suggestion.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcDiagnosticItem(f0) => {
                        __p.word("RustcDiagnosticItem");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcDoNotConstCheck => {
                        __p.word("RustcDoNotConstCheck")
                    }
                    Self::RustcDocPrimitive(f0, f1) => {
                        __p.word("RustcDocPrimitive");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcDummy => { __p.word("RustcDummy") }
                    Self::RustcDumpClauses => { __p.word("RustcDumpClauses") }
                    Self::RustcDumpDefParents => {
                        __p.word("RustcDumpDefParents")
                    }
                    Self::RustcDumpDefPath(f0) => {
                        __p.word("RustcDumpDefPath");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcDumpGenerics => { __p.word("RustcDumpGenerics") }
                    Self::RustcDumpHiddenTypeOfOpaques => {
                        __p.word("RustcDumpHiddenTypeOfOpaques")
                    }
                    Self::RustcDumpInferredOutlives => {
                        __p.word("RustcDumpInferredOutlives")
                    }
                    Self::RustcDumpItemBounds => {
                        __p.word("RustcDumpItemBounds")
                    }
                    Self::RustcDumpLayout(f0) => {
                        __p.word("RustcDumpLayout");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcDumpObjectLifetimeDefaults => {
                        __p.word("RustcDumpObjectLifetimeDefaults")
                    }
                    Self::RustcDumpSymbolName(f0) => {
                        __p.word("RustcDumpSymbolName");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcDumpUserArgs => { __p.word("RustcDumpUserArgs") }
                    Self::RustcDumpVariances => {
                        __p.word("RustcDumpVariances")
                    }
                    Self::RustcDumpVariancesOfOpaques => {
                        __p.word("RustcDumpVariancesOfOpaques")
                    }
                    Self::RustcDumpVtable(f0) => {
                        __p.word("RustcDumpVtable");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcDynIncompatibleTrait(f0) => {
                        __p.word("RustcDynIncompatibleTrait");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcEffectiveVisibility => {
                        __p.word("RustcEffectiveVisibility")
                    }
                    Self::RustcEiiForeignItem => {
                        __p.word("RustcEiiForeignItem")
                    }
                    Self::RustcEvaluateWhereClauses => {
                        __p.word("RustcEvaluateWhereClauses")
                    }
                    Self::RustcHasIncoherentInherentImpls => {
                        __p.word("RustcHasIncoherentInherentImpls")
                    }
                    Self::RustcIfThisChanged(f0, f1) => {
                        __p.word("RustcIfThisChanged");
                        if true && !f0.should_render() && !f1.should_render() {
                            return;
                        }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        if f1.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f1.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcInheritOverflowChecks => {
                        __p.word("RustcInheritOverflowChecks")
                    }
                    Self::RustcInsignificantDtor => {
                        __p.word("RustcInsignificantDtor")
                    }
                    Self::RustcIntrinsic => { __p.word("RustcIntrinsic") }
                    Self::RustcIntrinsicConstStableIndirect => {
                        __p.word("RustcIntrinsicConstStableIndirect")
                    }
                    Self::RustcLegacyConstGenerics { fn_indexes, attr_span } =>
                        {
                        __p.word("RustcLegacyConstGenerics");
                        if true && !fn_indexes.should_render() &&
                                !attr_span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if fn_indexes.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("fn_indexes");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        fn_indexes.print_attribute(__p);
                        if attr_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcLintOptDenyFieldAccess { lint_message } => {
                        __p.word("RustcLintOptDenyFieldAccess");
                        if true && !lint_message.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if lint_message.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("lint_message");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        lint_message.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcLintOptTy => { __p.word("RustcLintOptTy") }
                    Self::RustcLintQueryInstability => {
                        __p.word("RustcLintQueryInstability")
                    }
                    Self::RustcLintUntrackedQueryInformation => {
                        __p.word("RustcLintUntrackedQueryInformation")
                    }
                    Self::RustcMacroTransparency(f0) => {
                        __p.word("RustcMacroTransparency");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcMain => { __p.word("RustcMain") }
                    Self::RustcMir(f0) => {
                        __p.word("RustcMir");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcMustImplementOneOf { attr_span, fn_names } => {
                        __p.word("RustcMustImplementOneOf");
                        if true && !attr_span.should_render() &&
                                !fn_names.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if attr_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_span.print_attribute(__p);
                        if fn_names.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("fn_names");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        fn_names.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcMustMatchExhaustively(f0) => {
                        __p.word("RustcMustMatchExhaustively");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcNoImplicitAutorefs => {
                        __p.word("RustcNoImplicitAutorefs")
                    }
                    Self::RustcNoImplicitBounds => {
                        __p.word("RustcNoImplicitBounds")
                    }
                    Self::RustcNoMirInline => { __p.word("RustcNoMirInline") }
                    Self::RustcNoWritable => { __p.word("RustcNoWritable") }
                    Self::RustcNonConstTraitMethod => {
                        __p.word("RustcNonConstTraitMethod")
                    }
                    Self::RustcNonnullOptimizationGuaranteed => {
                        __p.word("RustcNonnullOptimizationGuaranteed")
                    }
                    Self::RustcNounwind => { __p.word("RustcNounwind") }
                    Self::RustcObjcClass { classname } => {
                        __p.word("RustcObjcClass");
                        if true && !classname.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if classname.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("classname");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        classname.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcObjcSelector { methname } => {
                        __p.word("RustcObjcSelector");
                        if true && !methname.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if methname.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("methname");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        methname.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcOffloadKernel => {
                        __p.word("RustcOffloadKernel")
                    }
                    Self::RustcPanicsWhenZero => {
                        __p.word("RustcPanicsWhenZero")
                    }
                    Self::RustcParenSugar => { __p.word("RustcParenSugar") }
                    Self::RustcPassByValue => { __p.word("RustcPassByValue") }
                    Self::RustcPassIndirectlyInNonRusticAbis(f0) => {
                        __p.word("RustcPassIndirectlyInNonRusticAbis");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcPreserveUbChecks => {
                        __p.word("RustcPreserveUbChecks")
                    }
                    Self::RustcProcMacroDecls => {
                        __p.word("RustcProcMacroDecls")
                    }
                    Self::RustcPubTransparent(f0) => {
                        __p.word("RustcPubTransparent");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcReallocator => { __p.word("RustcReallocator") }
                    Self::RustcRegions => { __p.word("RustcRegions") }
                    Self::RustcScalableVector { element_count } => {
                        __p.word("RustcScalableVector");
                        if true && !element_count.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if element_count.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("element_count");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        element_count.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcShouldNotBeCalledOnConstItems => {
                        __p.word("RustcShouldNotBeCalledOnConstItems")
                    }
                    Self::RustcShowSpans(f0) => {
                        __p.word("RustcShowSpans");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcSimdMonomorphizeLaneLimit(f0) => {
                        __p.word("RustcSimdMonomorphizeLaneLimit");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcSkipDuringMethodDispatch { array, boxed_slice }
                        => {
                        __p.word("RustcSkipDuringMethodDispatch");
                        if true && !array.should_render() &&
                                !boxed_slice.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if array.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("array");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        array.print_attribute(__p);
                        if boxed_slice.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("boxed_slice");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        boxed_slice.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::RustcSpecializationTrait => {
                        __p.word("RustcSpecializationTrait")
                    }
                    Self::RustcStdInternalSymbol => {
                        __p.word("RustcStdInternalSymbol")
                    }
                    Self::RustcStrictCoherence(f0) => {
                        __p.word("RustcStrictCoherence");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcTestMarker(f0) => {
                        __p.word("RustcTestMarker");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcThenThisWouldNeed(f0) => {
                        __p.word("RustcThenThisWouldNeed");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::RustcTrivialFieldReads => {
                        __p.word("RustcTrivialFieldReads")
                    }
                    Self::Sanitize { on_set, off_set, rtsan, span } => {
                        __p.word("Sanitize");
                        if true && !on_set.should_render() &&
                                        !off_set.should_render() && !rtsan.should_render() &&
                                !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if on_set.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("on_set");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        on_set.print_attribute(__p);
                        if off_set.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("off_set");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        off_set.print_attribute(__p);
                        if rtsan.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("rtsan");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        rtsan.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::ShouldPanic { reason } => {
                        __p.word("ShouldPanic");
                        if true && !reason.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if reason.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("reason");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        reason.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::Splat(f0) => {
                        __p.word("Splat");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Stability { stability, span } => {
                        __p.word("Stability");
                        if true && !stability.should_render() &&
                                !span.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if stability.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("stability");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        stability.print_attribute(__p);
                        if span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        span.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::TargetFeature { features, attr_span, was_forced } => {
                        __p.word("TargetFeature");
                        if true && !features.should_render() &&
                                    !attr_span.should_render() && !was_forced.should_render() {
                            return;
                        }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if features.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("features");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        features.print_attribute(__p);
                        if attr_span.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("attr_span");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        attr_span.print_attribute(__p);
                        if was_forced.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("was_forced");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        was_forced.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::TestRunner(f0) => {
                        __p.word("TestRunner");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::ThreadLocal => { __p.word("ThreadLocal") }
                    Self::TrackCaller(f0) => {
                        __p.word("TrackCaller");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::TypeLengthLimit { limit } => {
                        __p.word("TypeLengthLimit");
                        if true && !limit.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if limit.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("limit");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        limit.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::UncheckedTypeAlias => {
                        __p.word("UncheckedTypeAlias")
                    }
                    Self::Unroll(f0) => {
                        __p.word("Unroll");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::UnstableFeatureBound(f0) => {
                        __p.word("UnstableFeatureBound");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::UnstableRemoved(f0) => {
                        __p.word("UnstableRemoved");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                    Self::Used { used_by } => {
                        __p.word("Used");
                        if true && !used_by.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if used_by.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("used_by");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        used_by.print_attribute(__p);
                        __p.word("}");
                    }
                    Self::WindowsSubsystem(f0) => {
                        __p.word("WindowsSubsystem");
                        if true && !f0.should_render() { return; }
                        __p.popen();
                        let mut __printed_anything = false;
                        if f0.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __printed_anything = true;
                        }
                        f0.print_attribute(__p);
                        __p.pclose();
                    }
                }
            }
        }
    };PrintAttribute)]
826pub enum AttributeKind {
827    // tidy-alphabetical-start
828    /// Represents `#[allow_internal_unsafe]`.
829    AllowInternalUnsafe(Span),
830
831    /// Represents `#[allow_internal_unstable]`.
832    AllowInternalUnstable(ThinVec<(Symbol, Span)>, Span),
833
834    /// Represents `#[rustc_always_gca]`
835    AlwaysGca,
836
837    /// Represents `#[automatically_derived]`
838    AutomaticallyDerived,
839
840    /// Represents the trace attribute of `#[cfg_attr]`
841    CfgAttrTrace(ThinVec<(CfgEntry, Span)>),
842
843    /// Represents the trace attribute of `#[cfg]`
844    CfgTrace(ThinVec<(CfgEntry, Span)>),
845
846    /// Represents `#[cfi_encoding]`
847    CfiEncoding {
848        encoding: Symbol,
849    },
850
851    /// Represents `#[cold]`.
852    Cold,
853
854    /// Represents `#[collapse_debuginfo]`.
855    CollapseDebugInfo(CollapseMacroDebuginfo),
856
857    /// Represents `#[compiler_builtins]`.
858    CompilerBuiltins,
859
860    /// Represents `#[const_continue]`.
861    ConstContinue(Span),
862
863    /// Represents `#[coroutine]`.
864    Coroutine,
865
866    /// Represents `#[coverage(..)]`.
867    Coverage(CoverageAttrKind),
868
869    /// Represents `#[crate_name = ...]`
870    CrateName {
871        name: Symbol,
872        name_span: Span,
873        attr_span: Span,
874    },
875
876    /// Represents `#![crate_type = ...]`
877    CrateType(ThinVec<CrateType>),
878
879    /// Represents `#[custom_mir]`.
880    CustomMir(Option<(MirDialect, Span)>, Option<(MirPhase, Span)>),
881
882    /// Represents `#[debugger_visualizer]`.
883    DebuggerVisualizer(ThinVec<DebugVisualizer>),
884
885    /// Represents `#![default_lib_allocator]`
886    DefaultLibAllocator,
887
888    /// Represents [`#[deprecated]`](https://doc.rust-lang.org/stable/reference/attributes/diagnostics.html#the-deprecated-attribute).
889    Deprecated {
890        deprecation: Deprecation,
891        span: Span,
892        /// `true` if this an inner attribute (ie `#![]`).
893        is_inner: bool,
894    },
895
896    /// Represents `#[diagnostic::do_not_recommend]`.
897    DoNotRecommend,
898
899    /// Represents [`#[doc]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html).
900    /// Represents all other uses of the [`#[doc]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html)
901    /// attribute.
902    Doc(Box<DocAttribute>),
903
904    /// Represents specifically [`#[doc = "..."]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html).
905    /// i.e. doc comments.
906    DocComment {
907        style: AttrStyle,
908        kind: DocFragmentKind,
909        span: Span,
910        comment: Symbol,
911    },
912
913    /// Implementation detail of `#[eii]`
914    EiiDeclaration(EiiDecl),
915
916    /// Implementation detail of `#[eii]`
917    EiiImpl(Box<EiiImpl>),
918
919    /// Represents [`#[export_name]`](https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute).
920    ExportName {
921        /// The name to export this item with.
922        /// It may not contain \0 bytes as it will be converted to a null-terminated string.
923        name: Symbol,
924        span: Span,
925    },
926
927    /// Represents `#[export_stable]`.
928    ExportStable,
929
930    /// Represents `#[feature(...)]`
931    Feature(ThinVec<Ident>, Span),
932
933    /// Represents `#[ffi_const]`.
934    FfiConst,
935
936    /// Represents `#[ffi_pure]`.
937    FfiPure(Span),
938
939    /// Represents `#[fundamental]`.
940    Fundamental,
941
942    /// Represents `#[ignore]`
943    Ignore {
944        span: Span,
945        /// ignore can optionally have a reason: `#[ignore = "reason this is ignored"]`
946        reason: Option<Symbol>,
947    },
948
949    /// Represents `#[inline]` and `#[rustc_force_inline]`.
950    Inline(InlineAttr, Span),
951
952    /// Represents `#[instruction_set]`
953    InstructionSet(InstructionSetAttr),
954
955    /// Represents `#[instrument_fn]`
956    InstrumentFn(InstrumentFnAttr),
957
958    /// Represents `#[lang]`
959    Lang(LangItem),
960
961    /// Represents `#[link]`.
962    Link(ThinVec<LinkEntry>, Span),
963
964    /// Represents `#[link_name]`.
965    LinkName {
966        name: Symbol,
967        span: Span,
968    },
969
970    /// Represents `#[link_ordinal]`.
971    LinkOrdinal {
972        ordinal: u16,
973        span: Span,
974    },
975
976    /// Represents [`#[link_section]`](https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute)
977    LinkSection {
978        name: Symbol,
979    },
980
981    /// Represents `#[linkage]`.
982    Linkage(Linkage, Span),
983
984    /// Represents `#[lint::as_ptr]` (used by the `dangling_pointers_from_temporaries` lint).
985    LintAsPtr,
986
987    /// Represents `#[allow]`, `#[warn]`, `#[deny]`, `#[forbid]`, and `#[expect]`.
988    LintCheck(ThinVec<LintCheck>),
989
990    /// Represents `#[lint::never_returns_null_ptr]` (used by the `useless_ptr_null_checks` lint).
991    LintNeverReturnsNullPtr,
992
993    /// Represents `#[lint::should_not_be_called_on_const_items]` (used by the
994    /// `const_item_interior_mutations` lint).
995    LintShouldNotBeCalledOnConstItems,
996
997    /// Represents `#[loop_match]`.
998    LoopMatch(Span),
999
1000    /// Represents `#[macro_escape]`.
1001    MacroEscape,
1002
1003    /// Represents [`#[macro_export]`](https://doc.rust-lang.org/reference/macros-by-example.html#r-macro.decl.scope.path).
1004    MacroExport {
1005        span: Span,
1006        local_inner_macros: bool,
1007    },
1008
1009    /// Represents `#[macro_use]`.
1010    MacroUse {
1011        span: Span,
1012        arguments: MacroUseArgs,
1013    },
1014
1015    /// Represents `#[marker]`.
1016    Marker,
1017
1018    /// Represents [`#[may_dangle]`](https://std-dev-guide.rust-lang.org/tricky/may-dangle.html).
1019    MayDangle(Span),
1020
1021    /// Represents `#[move_size_limit]`
1022    MoveSizeLimit {
1023        limit: Limit,
1024    },
1025
1026    /// Represents `#[must_not_suspend]`
1027    MustNotSupend {
1028        reason: Option<Symbol>,
1029    },
1030
1031    /// Represents `#[must_use]`.
1032    MustUse {
1033        /// Used by `clippy`.
1034        span: Span,
1035        /// must_use can optionally have a reason: `#[must_use = "reason this must be used"]`
1036        reason: Option<Symbol>,
1037    },
1038
1039    /// Represents `#[naked]`
1040    Naked(Span),
1041
1042    /// Represents `#[needs_allocator]`
1043    NeedsAllocator,
1044
1045    /// Represents `#[needs_panic_runtime]`
1046    NeedsPanicRuntime,
1047
1048    /// Represents `#[no_builtins]`
1049    NoBuiltins,
1050
1051    /// Represents `#[no_core]`
1052    NoCore,
1053
1054    /// Represents `#[no_implicit_prelude]`
1055    NoImplicitPrelude,
1056
1057    /// Represents `#[no_link]`
1058    NoLink,
1059
1060    /// Represents `#[no_main]`
1061    NoMain,
1062
1063    /// Represents `#[no_mangle]`
1064    NoMangle(Span),
1065
1066    /// Represents `#[no_std]`
1067    NoStd,
1068
1069    /// Represents `#[non_exhaustive]`
1070    NonExhaustive(Span),
1071
1072    /// Represents `#[diagnostic::on_const]`.
1073    OnConst {
1074        /// The attribute path span.
1075        span: Span,
1076        /// None if the directive was malformed in some way.
1077        directive: Option<Box<Directive>>,
1078    },
1079
1080    /// Represents `#[diagnostic::on_move]`
1081    OnMove {
1082        directive: Option<Box<Directive>>,
1083    },
1084
1085    /// Represents`#[diagnostic::on_type_error]`.
1086    OnTypeError {
1087        span: Span,
1088        directive: Option<Box<Directive>>,
1089    },
1090
1091    /// Represents `#[rustc_on_unimplemented]` and `#[diagnostic::on_unimplemented]`.
1092    OnUnimplemented {
1093        /// None if the directive was malformed in some way.
1094        directive: Option<Box<Directive>>,
1095    },
1096
1097    /// Represents `#[diagnostic::on_unknown]`
1098    OnUnknown {
1099        /// None if the directive was malformed in some way.
1100        directive: Option<Box<Directive>>,
1101    },
1102
1103    /// Represents `#[diagnostic::on_unmatched_args]`.
1104    OnUnmatchedArgs {
1105        /// None if the directive was malformed in some way.
1106        directive: Option<Box<Directive>>,
1107    },
1108
1109    /// Represents `#[diagnostic::opaque]`.
1110    Opaque,
1111
1112    /// Represents `#[optimize(size|speed)]`
1113    Optimize(OptimizeAttr, Span),
1114
1115    /// Represents `#[panic_runtime]`
1116    PanicRuntime,
1117
1118    /// Represents `#[patchable_function_entry]`
1119    PatchableFunctionEntry {
1120        prefix: Option<u8>,
1121        entry: Option<u8>,
1122        section: Option<Symbol>,
1123    },
1124
1125    /// Represents `#[path]`
1126    Path(Symbol, Span),
1127
1128    /// Represents `#[pattern_complexity_limit]`
1129    PatternComplexityLimit {
1130        limit: Limit,
1131    },
1132
1133    /// Represents `#[pin_v2]`
1134    PinV2(Span),
1135
1136    /// Represents `#[prelude_import]`
1137    PreludeImport,
1138
1139    /// Represents `#[proc_macro]`
1140    ProcMacro,
1141
1142    /// Represents `#[proc_macro_attribute]`
1143    ProcMacroAttribute,
1144
1145    /// Represents `#[proc_macro_derive]`
1146    ProcMacroDerive {
1147        trait_name: Symbol,
1148        helper_attrs: ThinVec<Symbol>,
1149    },
1150
1151    /// Represents `#[profiler_runtime]`
1152    ProfilerRuntime,
1153
1154    /// Represents [`#[recursion_limit]`](https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute)
1155    RecursionLimit {
1156        limit: Limit,
1157    },
1158
1159    /// Represents `#[reexport_test_harness_main]`
1160    ReexportTestHarnessMain(Symbol),
1161
1162    /// Represents `#[register_attribute_tool]`, `#[register_lint_tool]` and `#[register_tool]`
1163    RegisterTool {
1164        attr_tools: ThinVec<Ident>,
1165        lint_tools: ThinVec<Ident>,
1166    },
1167
1168    /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
1169    Repr {
1170        reprs: ThinVec<(ReprAttr, Span)>,
1171        first_span: Span,
1172    },
1173
1174    /// Represents `#[rustc_abi(..)]`
1175    RustcAbi {
1176        attr_span: Span,
1177        kind: RustcAbiAttrKind,
1178    },
1179
1180    /// Represents `#[align(N)]`.
1181    // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
1182    RustcAlign {
1183        align: Align,
1184        span: Span,
1185    },
1186
1187    /// Represents `#[rustc_allocator]`
1188    RustcAllocator,
1189
1190    /// Represents `#[rustc_allocator_zeroed]`
1191    RustcAllocatorZeroed,
1192
1193    /// Represents `#[rustc_allocator_zeroed_variant]`
1194    RustcAllocatorZeroedVariant {
1195        name: Symbol,
1196    },
1197
1198    /// Represents `#[rustc_allow_const_fn_unstable]`.
1199    RustcAllowConstFnUnstable(ThinVec<Symbol>, Span),
1200
1201    /// Represents `#[rustc_allow_incoherent_impl]`.
1202    RustcAllowIncoherentImpl(Span),
1203
1204    /// Represents `#[rustc_allow_lifetime_dependent_specialization]`.
1205    RustcAllowLifetimeDependentSpecialization,
1206
1207    /// Represents `#[rustc_assert_variance]`.
1208    RustcAssertVariance {
1209        span: Span,
1210        kind: RustcAssertVarianceKind,
1211    },
1212
1213    /// Represents `#[rustc_autodiff]`.
1214    RustcAutodiff(Option<Box<RustcAutodiff>>),
1215
1216    /// Represents `#[rustc_default_body_unstable]`.
1217    RustcBodyStability {
1218        stability: DefaultBodyStability,
1219        /// Span of the `#[rustc_default_body_unstable(...)]` attribute
1220        span: Span,
1221    },
1222    /// Represents `#[rustc_builtin_macro]`.
1223    RustcBuiltinMacro {
1224        builtin_name: Option<Symbol>,
1225        helper_attrs: ThinVec<Symbol>,
1226    },
1227
1228    /// Represents `#[rustc_canonical_symbol]`
1229    RustcCanonicalSymbol,
1230
1231    /// Represents `#[rustc_capture_analysis]`
1232    RustcCaptureAnalysis,
1233
1234    /// Represents `#[rustc_expected_cgu_reuse]`, `#[rustc_partition_codegened]` and `#[rustc_partition_reused]`.
1235    RustcCguTestAttr(ThinVec<(Span, CguFields)>),
1236
1237    /// Represents `#[rustc_clean]`
1238    RustcClean(ThinVec<RustcCleanAttribute>),
1239
1240    /// Represents `#[rustc_coherence_is_core]`
1241    RustcCoherenceIsCore,
1242
1243    /// Represents `#[rustc_coinductive]`.
1244    RustcCoinductive,
1245
1246    /// Represents the [`rustc_comptime`](./attribute.rustc_comptime.html) attribute.
1247    RustcComptime(Span),
1248
1249    /// Represents `#[rustc_confusables]`.
1250    RustcConfusables {
1251        confusables: ThinVec<Symbol>,
1252    },
1253    /// Represents `#[rustc_const_stable]` and `#[rustc_const_unstable]`.
1254    RustcConstStability {
1255        stability: PartialConstStability,
1256        /// Path span of the `#[rustc_const_stable(...)]` or `#[rustc_const_unstable(...)]`
1257        /// attribute.
1258        span: Span,
1259    },
1260
1261    /// Represents `#[rustc_const_stable_indirect]`.
1262    RustcConstStableIndirect,
1263
1264    /// Represents `#[rustc_conversion_suggestion]`
1265    RustcConversionSuggestion,
1266
1267    /// Represents `#[rustc_deallocator]`
1268    RustcDeallocator,
1269
1270    /// Represents `#[rustc_delayed_bug_from_inside_query]`
1271    RustcDelayedBugFromInsideQuery,
1272
1273    /// Represents `#[rustc_deny_explicit_impl]`.
1274    RustcDenyExplicitImpl,
1275
1276    /// Represents `#[rustc_deprecated_safe_2024]`
1277    RustcDeprecatedSafe2024 {
1278        suggestion: Symbol,
1279    },
1280    /// Represents `#[rustc_diagnostic_item]`
1281    RustcDiagnosticItem(Symbol),
1282
1283    /// Represents `#[rustc_do_not_const_check]`
1284    RustcDoNotConstCheck,
1285
1286    /// Represents `#[rustc_doc_primitive = ...]`
1287    RustcDocPrimitive(Span, Symbol),
1288
1289    /// Represents `#[rustc_dummy]`.
1290    RustcDummy,
1291
1292    /// Represents the [`rustc_dump_clauses`](./attribute.rustc_dump_clauses.html) attribute.
1293    RustcDumpClauses,
1294
1295    /// Represents the [`rustc_dump_def_parents`](./attribute.rustc_dump_def_parents.html) attribute.
1296    RustcDumpDefParents,
1297
1298    /// Represents the [`rustc_dump_def_path`](./attribute.rustc_dump_def_path.html) attribute.
1299    RustcDumpDefPath(Span),
1300
1301    /// Represents the [`rustc_dump_generics`](./attribute.rustc_dump_generics.html) attribute.
1302    RustcDumpGenerics,
1303
1304    /// Represents the [`rustc_dump_hidden_type_of_opaques`](./attribute.rustc_dump_hidden_type_of_opaques.html) attribute.
1305    RustcDumpHiddenTypeOfOpaques,
1306
1307    /// Represents the [`rustc_dump_inferred_outlives`](./attribute.rustc_dump_inferred_outlives.html) attribute.
1308    RustcDumpInferredOutlives,
1309
1310    /// Represents the [`rustc_dump_item_bounds`](./attribute.rustc_dump_item_bounds.html) attribute.
1311    RustcDumpItemBounds,
1312
1313    /// Represents the [`rustc_dump_layout`](./attribute.rustc_dump_layout.html) attribute.
1314    RustcDumpLayout(ThinVec<RustcDumpLayoutKind>),
1315
1316    /// Represents the [`rustc_dump_object_lifetime_defaults`](./attribute.rustc_dump_object_lifetime_defaults.html) attribute.
1317    RustcDumpObjectLifetimeDefaults,
1318
1319    /// Represents the [`rustc_dump_symbol_name`](./attribute.rustc_dump_symbol_name.html) attribute.
1320    RustcDumpSymbolName(Span),
1321
1322    /// Represents `#[rustc_dump_user_args]`
1323    RustcDumpUserArgs,
1324
1325    /// Represents the [`rustc_dump_variances`](./attribute.rustc_dump_variances.html) attribute.
1326    RustcDumpVariances,
1327
1328    /// Represents the [`rustc_dump_variances_of_opaques`](./attribute.rustc_dump_variances_of_opaques.html) attribute.
1329    RustcDumpVariancesOfOpaques,
1330
1331    /// Represents the [`rustc_dump_vtable`](./attribute.rustc_dump_vtable.html) attribute.
1332    RustcDumpVtable(Span),
1333
1334    /// Represents the [`rustc_dyn_incompatible_trait`](./attribute.rustc_dyn_incompatible_trait.html) attribute.
1335    RustcDynIncompatibleTrait(Span),
1336
1337    /// Represents `#[rustc_effective_visibility]`.
1338    RustcEffectiveVisibility,
1339
1340    /// Implementation detail of `#[eii]`
1341    RustcEiiForeignItem,
1342
1343    /// Represents `#[rustc_evaluate_where_clauses]`
1344    RustcEvaluateWhereClauses,
1345
1346    RustcHasIncoherentInherentImpls,
1347
1348    /// Represents `#[rustc_if_this_changed]`
1349    RustcIfThisChanged(Span, Option<Symbol>),
1350
1351    /// Represents `#[rustc_inherit_overflow_checks]`
1352    RustcInheritOverflowChecks,
1353
1354    /// Represents `#[rustc_insignificant_dtor]`
1355    RustcInsignificantDtor,
1356
1357    /// Represents `#[rustc_intrinsic]`
1358    RustcIntrinsic,
1359
1360    /// Represents `#[rustc_intrinsic_const_stable_indirect]`
1361    RustcIntrinsicConstStableIndirect,
1362
1363    /// Represents `#[rustc_legacy_const_generics]`
1364    RustcLegacyConstGenerics {
1365        fn_indexes: ThinVec<(usize, Span)>,
1366        attr_span: Span,
1367    },
1368
1369    /// Represents `#[rustc_lint_opt_deny_field_access]`
1370    RustcLintOptDenyFieldAccess {
1371        lint_message: Symbol,
1372    },
1373
1374    /// Represents `#[rustc_lint_opt_ty]`
1375    RustcLintOptTy,
1376
1377    /// Represents `#[rustc_lint_query_instability]`
1378    RustcLintQueryInstability,
1379
1380    /// Represents `#[rustc_lint_untracked_query_information]`
1381    RustcLintUntrackedQueryInformation,
1382
1383    /// Represents `#[rustc_macro_transparency]`.
1384    RustcMacroTransparency(Transparency),
1385
1386    /// Represents `#[rustc_main]`.
1387    RustcMain,
1388
1389    /// Represents `#[rustc_mir]`.
1390    RustcMir(ThinVec<RustcMirKind>),
1391
1392    /// Represents `#[rustc_must_implement_one_of]`
1393    RustcMustImplementOneOf {
1394        attr_span: Span,
1395        fn_names: ThinVec<Ident>,
1396    },
1397
1398    /// Represents `#[rustc_must_match_exhaustively]`
1399    RustcMustMatchExhaustively(Span),
1400
1401    /// Represents `#[rustc_no_implicit_autorefs]`
1402    RustcNoImplicitAutorefs,
1403
1404    /// Represents `#[rustc_no_implicit_bounds]`
1405    RustcNoImplicitBounds,
1406
1407    /// Represents `#[rustc_no_mir_inline]`
1408    RustcNoMirInline,
1409
1410    /// Represents `#[rustc_no_writable]`
1411    RustcNoWritable,
1412
1413    /// Represents `#[rustc_non_const_trait_method]`.
1414    RustcNonConstTraitMethod,
1415
1416    /// Represents `#[rustc_nonnull_optimization_guaranteed]`.
1417    RustcNonnullOptimizationGuaranteed,
1418
1419    /// Represents `#[rustc_nounwind]`
1420    RustcNounwind,
1421
1422    /// Represents `#[rustc_objc_class]`
1423    RustcObjcClass {
1424        classname: Symbol,
1425    },
1426
1427    /// Represents `#[rustc_objc_selector]`
1428    RustcObjcSelector {
1429        methname: Symbol,
1430    },
1431
1432    /// Represents `#[rustc_offload_kernel]`
1433    RustcOffloadKernel,
1434
1435    /// Represents `#[rustc_panics_when_zero]` (used for linting).
1436    RustcPanicsWhenZero,
1437
1438    /// Represents `#[rustc_paren_sugar]`.
1439    RustcParenSugar,
1440
1441    /// Represents `#[rustc_pass_by_value]` (used by the `rustc_pass_by_value` lint).
1442    RustcPassByValue,
1443
1444    /// Represents `#[rustc_pass_indirectly_in_non_rustic_abis]`
1445    RustcPassIndirectlyInNonRusticAbis(Span),
1446
1447    /// Represents `#[rustc_preserve_ub_checks]`
1448    RustcPreserveUbChecks,
1449
1450    /// Represents `#[rustc_proc_macro_decls]`
1451    RustcProcMacroDecls,
1452
1453    /// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
1454    RustcPubTransparent(Span),
1455
1456    /// Represents `#[rustc_reallocator]`
1457    RustcReallocator,
1458
1459    /// Represents `#[rustc_regions]`
1460    RustcRegions,
1461
1462    /// Represents `#[rustc_scalable_vector(N)]`
1463    RustcScalableVector {
1464        /// The base multiple of lanes that are in a scalable vector, if provided. `element_count`
1465        /// is not provided for representing tuple types.
1466        element_count: Option<u16>,
1467    },
1468
1469    /// Represents `#[rustc_should_not_be_called_on_const_items]`
1470    RustcShouldNotBeCalledOnConstItems,
1471
1472    /// Represents `#[rustc_show_spans]`
1473    RustcShowSpans(ThinVec<RustcShowSpansKind>),
1474
1475    /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
1476    RustcSimdMonomorphizeLaneLimit(Limit),
1477
1478    /// Represents `#[rustc_skip_during_method_dispatch]`.
1479    RustcSkipDuringMethodDispatch {
1480        array: bool,
1481        boxed_slice: bool,
1482    },
1483
1484    /// Represents `#[rustc_specialization_trait]`.
1485    RustcSpecializationTrait,
1486
1487    /// Represents `#[rustc_std_internal_symbol]`.
1488    RustcStdInternalSymbol,
1489
1490    /// Represents `#[rustc_strict_coherence]`.
1491    RustcStrictCoherence(Span),
1492
1493    /// Represents `#[rustc_test_marker]`
1494    RustcTestMarker(Symbol),
1495
1496    /// Represents `#[rustc_then_this_would_need]`
1497    RustcThenThisWouldNeed(ThinVec<Ident>),
1498
1499    /// Represents `#[rustc_trivial_field_reads]`
1500    RustcTrivialFieldReads,
1501
1502    /// Represents `#[sanitize]`
1503    ///
1504    /// the on set and off set are distjoint since there's a third option: unset.
1505    /// a node may not set the sanitizer setting in which case it inherits from parents.
1506    /// rtsan is unset if None
1507    Sanitize {
1508        on_set: SanitizerSet,
1509        off_set: SanitizerSet,
1510        rtsan: Option<RtsanSetting>,
1511        span: Span,
1512    },
1513
1514    /// Represents `#[should_panic]`
1515    ShouldPanic {
1516        reason: Option<Symbol>,
1517    },
1518
1519    /// Represents `#[rustc_splat]`
1520    Splat(Span),
1521
1522    /// Represents `#[stable]`, `#[unstable]` and `#[rustc_allowed_through_unstable_modules]`.
1523    Stability {
1524        stability: Stability,
1525        /// Span of the attribute.
1526        span: Span,
1527    },
1528
1529    /// Represents `#[target_feature(enable = "...")]` and
1530    /// `#[unsafe(force_target_feature(enable = "...")]`.
1531    TargetFeature {
1532        features: ThinVec<(Symbol, Span)>,
1533        attr_span: Span,
1534        was_forced: bool,
1535    },
1536
1537    /// Represents `#![test_runner(path)]`
1538    TestRunner(Path),
1539
1540    /// Represents `#[thread_local]`
1541    ThreadLocal,
1542
1543    /// Represents `#[track_caller]`
1544    TrackCaller(Span),
1545
1546    /// Represents `#[type_length_limit]`
1547    TypeLengthLimit {
1548        limit: Limit,
1549    },
1550
1551    /// Represents `#[rustc_unchecked_type_alias]`
1552    // FIXME(#134963): Temporarily prefixed with `rustc_` to prevent potential name resolution ambiguities.
1553    UncheckedTypeAlias,
1554
1555    /// Represents `#[rustc_unroll]`
1556    // FIXME(#159429): temporarily renamed from `#[unroll]` to mitigate nameres ambiguity
1557    Unroll(UnrollAttr),
1558
1559    /// Represents `#[unstable_feature_bound]`.
1560    UnstableFeatureBound(ThinVec<(Symbol, Span)>),
1561
1562    /// Represents all `#![unstable_removed(...)]` features
1563    UnstableRemoved(ThinVec<UnstableRemovedFeature>),
1564
1565    /// Represents `#[used]`
1566    Used {
1567        used_by: UsedBy,
1568    },
1569
1570    /// Represents `#[windows_subsystem]`.
1571    WindowsSubsystem(WindowsSubsystemKind),
1572    // tidy-alphabetical-end
1573}