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_lint_defs::ToolOptions;
16use rustc_macros::{
17    Decodable, Decodable_NoContext, Encodable, Encodable_NoContext, PrintAttribute, StableHash,
18};
19use rustc_span::def_id::DefId;
20use rustc_span::hygiene::Transparency;
21use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
22use rustc_structures::{CollapseMacroDebuginfo, CrateType, Limit, NativeLibKind, SanitizerSet};
23use thin_vec::ThinVec;
24
25pub use crate::canonical_symbols::{CanonicalSymbol, CanonicalSymbols};
26use crate::diagnostic::*;
27use crate::lang_items::LangItem;
28use crate::lint::LintCheck;
29use crate::pretty_printing::PrintAttribute;
30use crate::stability::{DefaultBodyStability, PartialConstStability, Stability};
31
32#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
33pub enum EiiImplResolution {
34    /// Usually, finding the extern item that an EII implementation implements means finding
35    /// the defid of the associated attribute macro, and looking at *its* attributes to find
36    /// what foreign item its associated with.
37    Macro(DefId),
38    /// Sometimes though, we already know statically and can skip some name resolution.
39    /// DefId of the extern item that the EII implementation implements.
40    Known(DefId),
41    /// For when resolution failed, but we want to continue compilation
42    Error(ErrorGuaranteed),
43}
44
45#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
46pub struct EiiImpl {
47    pub resolution: EiiImplResolution,
48    pub impl_unsafe_span: Option<Span>,
49    pub span: Span,
50    pub inner_span: Span,
51    pub is_default: bool,
52}
53
54#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
55pub struct EiiDecl {
56    pub foreign_item: DefId,
57    /// whether or not it is unsafe to implement this EII
58    pub impl_unsafe: bool,
59    pub name: Ident,
60}
61
62#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
63pub enum CguKind {
64    No,
65    PreDashLto,
66    PostDashLto,
67    Any,
68}
69
70#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
71pub enum CguFields {
72    PartitionReused { cfg: Symbol, module: Symbol },
73    PartitionCodegened { cfg: Symbol, module: Symbol },
74    ExpectedCguReuse { cfg: Symbol, module: Symbol, kind: CguKind },
75}
76
77#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
78pub enum InlineAttr {
79    None,
80    Hint,
81    Always,
82    Never,
83    /// `#[rustc_force_inline]` forces inlining to happen in the MIR inliner - it reports an error
84    /// if the inlining cannot happen. It is limited to only free functions so that the calls
85    /// can always be resolved.
86    Force {
87        attr_span: Span,
88        reason: Option<Symbol>,
89    },
90}
91
92impl InlineAttr {
93    pub fn always(&self) -> bool {
94        match self {
95            InlineAttr::Always | InlineAttr::Force { .. } => true,
96            InlineAttr::None | InlineAttr::Hint | InlineAttr::Never => false,
97        }
98    }
99}
100
101#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
102pub enum UnrollAttr {
103    Hint,
104    Full,
105    Never,
106    Count(u32),
107}
108
109#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
110pub enum InstructionSetAttr {
111    ArmA32,
112    ArmT32,
113}
114
115#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for InstrumentFnAttr {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
116#[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)]
117pub enum InstrumentFnAttr {
118    /// `#[instrument_fn = "on"]`
119    On,
120    /// `#[instrument_fn = "off"]`
121    Off,
122}
123
124#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for OptimizeAttr {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
125#[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)]
126pub enum OptimizeAttr {
127    /// No `#[optimize(..)]` attribute
128    #[default]
129    Default,
130    /// `#[optimize(none)]`
131    DoNotOptimize,
132    /// `#[optimize(speed)]`
133    Speed,
134    /// `#[optimize(size)]`
135    Size,
136}
137
138impl OptimizeAttr {
139    pub fn do_not_optimize(&self) -> bool {
140        #[allow(non_exhaustive_omitted_patterns)] match self {
    Self::DoNotOptimize => true,
    _ => false,
}matches!(self, Self::DoNotOptimize)
141    }
142}
143
144#[derive(
145    #[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,
146    #[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,
147    #[automatically_derived]impl ::core::fmt::Debug for ReprAttr {
    #[inline]
    #[rustc_trivial_field_reads]
    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,
148    #[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,
149    #[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,
150    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,
151    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,
152    #[automatically_derived]impl ::core::marker::Copy for ReprAttr { }Copy,
153    #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for ReprAttr {
}
#[automatically_derived]impl ::core::clone::Clone for ReprAttr {
    #[inline]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<IntType>;
        let _: ::core::clone::AssertParamIsClone<Align>;
        *self
    }
}Clone,
154    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,
155    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
156)]
157pub enum ReprAttr {
158    ReprInt(IntType),
159    ReprRust,
160    ReprC,
161    ReprPacked(Align),
162    ReprSimd,
163    ReprTransparent,
164    ReprAlign(Align),
165}
166
167#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
168#[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)]
169pub enum IntType {
170    SignedInt(ast::IntTy),
171    UnsignedInt(ast::UintTy),
172}
173
174#[derive(#[automatically_derived]impl ::core::marker::Copy for Deprecation { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Deprecation {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
175pub struct Deprecation {
176    pub since: DeprecatedSince,
177    /// The note to issue a reason.
178    pub note: Option<Ident>,
179    /// A text snippet used to completely replace any use of the deprecated item in an expression.
180    ///
181    /// This is currently unstable.
182    pub suggestion: Option<Symbol>,
183}
184
185/// Release in which an API is deprecated.
186#[derive(#[automatically_derived]impl ::core::marker::Copy for DeprecatedSince { }Copy, #[automatically_derived]impl ::core::fmt::Debug for DeprecatedSince {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
187pub enum DeprecatedSince {
188    RustcVersion(RustcVersion),
189    /// Deprecated in the future ("to be determined").
190    Future,
191    /// `feature(staged_api)` is off. Deprecation versions outside the standard
192    /// library are allowed to be arbitrary strings, for better or worse.
193    NonStandard(Symbol),
194    /// Deprecation version is unspecified but optional.
195    Unspecified,
196    /// Failed to parse a deprecation version, or the deprecation version is
197    /// unspecified and required. An error has already been emitted.
198    Err,
199}
200
201/// Successfully-parsed value of a `#[coverage(..)]` attribute.
202#[derive(#[automatically_derived]impl ::core::marker::Copy for CoverageAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for CoverageAttrKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone)]
203#[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)]
204pub enum CoverageAttrKind {
205    On,
206    Off,
207}
208
209/// Successfully-parsed value of a `#[rustc_abi(..)]` attribute.
210#[derive(#[automatically_derived]impl ::core::marker::Copy for RustcAbiAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RustcAbiAttrKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone)]
211#[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)]
212pub enum RustcAbiAttrKind {
213    Debug,
214    AssertEq,
215}
216
217impl Deprecation {
218    /// Whether an item marked with #[deprecated(since = "X")] is currently
219    /// deprecated (i.e., whether X is not greater than the current rustc
220    /// version).
221    pub fn is_in_effect(&self) -> bool {
222        match self.since {
223            DeprecatedSince::RustcVersion(since) => since <= RustcVersion::CURRENT,
224            DeprecatedSince::Future => false,
225            // The `since` field doesn't have semantic purpose without `#![staged_api]`.
226            DeprecatedSince::NonStandard(_) => true,
227            // Assume deprecation is in effect if "since" field is absent or invalid.
228            DeprecatedSince::Unspecified | DeprecatedSince::Err => true,
229        }
230    }
231
232    pub fn is_since_rustc_version(&self) -> bool {
233        #[allow(non_exhaustive_omitted_patterns)] match self.since {
    DeprecatedSince::RustcVersion(_) => true,
    _ => false,
}matches!(self.since, DeprecatedSince::RustcVersion(_))
234    }
235}
236
237/// There are three valid forms of the attribute:
238/// `#[used]`, which is equivalent to `#[used(linker)]` on targets that support it, but `#[used(compiler)]` if not.
239/// `#[used(compiler)]`
240/// `#[used(linker)]`
241#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for UsedBy {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
242#[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)]
243pub enum UsedBy {
244    Default,
245    Compiler,
246    Linker,
247}
248
249#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
250#[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)]
251pub enum MacroUseArgs {
252    UseAll,
253    UseSpecific(ThinVec<Ident>),
254}
255
256impl Default for MacroUseArgs {
257    fn default() -> Self {
258        Self::UseSpecific(ThinVec::new())
259    }
260}
261
262#[derive(#[automatically_derived]impl<ScopeId: ::core::fmt::Debug> ::core::fmt::Debug
    for StrippedCfgItem<ScopeId> {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
263pub struct StrippedCfgItem<ScopeId = DefId> {
264    pub parent_scope: ScopeId,
265    pub ident: Ident,
266    pub cfg: (CfgEntry, Span),
267}
268
269impl<ScopeId> StrippedCfgItem<ScopeId> {
270    pub fn map_scope_id<New>(self, f: impl FnOnce(ScopeId) -> New) -> StrippedCfgItem<New> {
271        StrippedCfgItem { parent_scope: f(self.parent_scope), ident: self.ident, cfg: self.cfg }
272    }
273}
274
275/// Possible values for the `#[linkage]` attribute, allowing to specify the
276/// linkage type for a `MonoItem`.
277///
278/// See <https://llvm.org/docs/LangRef.html#linkage-types> for more details about these variants.
279#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for Linkage { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Linkage {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
280#[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)]
281pub enum Linkage {
282    AvailableExternally,
283    ExternalWeak,
284    External,
285    Internal,
286    LinkOnceAny,
287    LinkOnceODR,
288    WeakAny,
289    WeakODR,
290}
291
292#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for MirDialect {
}
#[automatically_derived]impl ::core::clone::Clone for MirDialect {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
293#[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)]
294pub enum MirDialect {
295    Analysis,
296    Built,
297    Runtime,
298}
299
300impl IntoDiagArg for MirDialect {
301    fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
302        let arg = match self {
303            MirDialect::Analysis => "analysis",
304            MirDialect::Built => "built",
305            MirDialect::Runtime => "runtime",
306        };
307        DiagArgValue::Str(Cow::Borrowed(arg))
308    }
309}
310
311#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for MirPhase {
}
#[automatically_derived]impl ::core::clone::Clone for MirPhase {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
312#[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)]
313pub enum MirPhase {
314    Initial,
315    PostCleanup,
316    Optimized,
317}
318
319impl IntoDiagArg for MirPhase {
320    fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
321        let arg = match self {
322            MirPhase::Initial => "initial",
323            MirPhase::PostCleanup => "post-cleanup",
324            MirPhase::Optimized => "optimized",
325        };
326        DiagArgValue::Str(Cow::Borrowed(arg))
327    }
328}
329
330/// Different ways that the PE Format can decorate a symbol name.
331/// From <https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-name-type>
332#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<u16>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for PeImportNameType {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
333pub enum PeImportNameType {
334    /// IMPORT_ORDINAL
335    /// Uses the ordinal (i.e., a number) rather than the name.
336    Ordinal(u16),
337    /// Same as IMPORT_NAME
338    /// Name is decorated with all prefixes and suffixes.
339    Decorated,
340    /// Same as IMPORT_NAME_NOPREFIX
341    /// Prefix (e.g., the leading `_` or `@`) is skipped, but suffix is kept.
342    NoPrefix,
343    /// Same as IMPORT_NAME_UNDECORATE
344    /// Prefix (e.g., the leading `_` or `@`) and suffix (the first `@` and all
345    /// trailing characters) are skipped.
346    Undecorated,
347}
348
349#[derive(#[automatically_derived]impl ::core::fmt::Debug for LinkEntry {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
350pub struct LinkEntry {
351    pub span: Span,
352    pub kind: NativeLibKind,
353    pub name: Symbol,
354    pub cfg: Option<CfgEntry>,
355    pub verbatim: Option<bool>,
356    pub import_name_type: Option<(PeImportNameType, Span)>,
357}
358
359#[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)]
360#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
361pub enum DebuggerVisualizerType {
362    Natvis,
363    GdbPrettyPrinter,
364}
365
366#[derive(#[automatically_derived]impl ::core::fmt::Debug for DebugVisualizer {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
367pub struct DebugVisualizer {
368    pub span: Span,
369    pub visualizer_type: DebuggerVisualizerType,
370    pub path: Symbol,
371}
372
373#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for RtsanSetting {
}
#[automatically_derived]impl ::core::clone::Clone for RtsanSetting {
    #[inline]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for RtsanSetting { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RtsanSetting {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
374#[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)]
375#[derive_const(#[automatically_derived]const impl ::core::default::Default for RtsanSetting {
    #[inline]
    fn default() -> Self { Self::Caller }
}Default)]
376pub enum RtsanSetting {
377    Nonblocking,
378    Blocking,
379    #[default]
380    Caller,
381}
382
383#[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]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone)]
384#[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)]
385pub enum WindowsSubsystemKind {
386    Console,
387    Windows,
388}
389
390impl WindowsSubsystemKind {
391    pub fn as_str(&self) -> &'static str {
392        match self {
393            WindowsSubsystemKind::Console => "console",
394            WindowsSubsystemKind::Windows => "windows",
395        }
396    }
397}
398
399#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocInline {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
400#[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)]
401pub enum DocInline {
402    Inline,
403    NoInline,
404}
405
406#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for HideOrShow {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
407#[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)]
408pub enum HideOrShow {
409    Hide,
410    Show,
411}
412
413#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for DocCfgHideShowValue {
}
#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShowValue {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
414pub struct DocCfgHideShowValue {
415    pub span: Span,
416    /// If `value` is `None`, then it's a `none()` value.
417    pub value: Option<Symbol>,
418}
419
420impl DocCfgHideShowValue {
421    pub fn new(value: Symbol, span: Span) -> Self {
422        Self { span, value: Some(value) }
423    }
424
425    pub fn new_none(span: Span) -> Self {
426        Self { span, value: None }
427    }
428}
429
430#[derive(#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShow {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
431pub enum DocCfgHideShow {
432    Any(Span),
433    List(ThinVec<DocCfgHideShowValue>),
434}
435
436impl DocCfgHideShow {
437    pub fn new() -> Self {
438        Self::List(ThinVec::new())
439    }
440
441    pub fn new_with_only_key(span: Span) -> Self {
442        let mut values = ThinVec::with_capacity(1);
443        values.push(DocCfgHideShowValue { span, value: None });
444        Self::List(values)
445    }
446
447    pub fn push_none(&mut self, span: Span) {
448        if let Self::List(values) = self
449            && !values.iter().any(|v| v.value.is_none())
450        {
451            values.push(DocCfgHideShowValue { span, value: None });
452        }
453    }
454
455    pub fn merge_with(&mut self, other: &Self) {
456        match (self, other) {
457            (Self::Any(_), Self::Any(_) | Self::List(_)) => {
458                // Nothing to do.
459            }
460            (s, Self::Any(span)) => {
461                // We "upgrade" the list values to "all".
462                *s = Self::Any(*span);
463            }
464            (Self::List(values), Self::List(other_values)) => {
465                // Having duplicates is not an issue, we simply ignore them. Would be more
466                // convenient to have a `set` type though. T_T
467                for other in other_values {
468                    if !values.iter().any(|value| value.value == other.value) {
469                        values.push(*other);
470                    }
471                }
472            }
473        }
474    }
475}
476
477#[derive(#[automatically_derived]impl ::core::clone::Clone for CfgHideShow {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
478pub struct CfgHideShow {
479    pub kind: HideOrShow,
480    pub values: FxIndexMap<Symbol, DocCfgHideShow>,
481}
482
483#[derive(#[automatically_derived]impl ::core::clone::Clone for DocAttribute {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
484pub struct DocAttribute {
485    pub first_span: Span,
486
487    pub aliases: FxIndexMap<Symbol, Span>,
488    pub hidden: Option<Span>,
489    pub inline: Option<(DocInline, Span)>,
490
491    // unstable
492    pub cfg: ThinVec<CfgEntry>,
493    pub auto_cfg: ThinVec<(CfgHideShow, Span)>,
494    /// This is for `#[doc(auto_cfg = false|true)]`/`#[doc(auto_cfg)]`.
495    pub auto_cfg_change: ThinVec<(bool, Span)>,
496
497    // builtin
498    pub fake_variadic: Option<Span>,
499    pub keyword: Option<(Symbol, Span)>,
500    pub attribute: Option<(Symbol, Span)>,
501    pub masked: Option<Span>,
502    pub notable_trait: Option<(Option<(NotableTraitColor, Span)>, Span)>,
503    pub search_unbox: Option<Span>,
504
505    // valid on crate
506    pub html_favicon_url: Option<(Symbol, Span)>,
507    pub html_logo_url: Option<(Symbol, Span)>,
508    pub html_playground_url: Option<(Symbol, Span)>,
509    pub html_root_url: Option<(Symbol, Span)>,
510    pub html_no_source: Option<Span>,
511    pub issue_tracker_base_url: Option<(Symbol, Span)>,
512    pub rust_logo: Option<Span>,
513
514    // #[doc(test(...))]
515    pub test_attrs: ThinVec<Span>,
516    pub no_crate_inject: Option<Span>,
517}
518
519#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for NotableTraitColor {
}
#[automatically_derived]impl ::core::clone::Clone for NotableTraitColor {
    #[inline]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for NotableTraitColor { }Copy, #[automatically_derived]impl ::core::fmt::Debug for NotableTraitColor {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
520#[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)]
521pub enum NotableTraitColor {
522    Grey,
523    Red,
524    Green,
525    Yellow,
526    Blue,
527    Magenta,
528    Cyan,
529    Transparent,
530}
531
532impl From<NotableTraitColor> for &'static str {
533    fn from(color: NotableTraitColor) -> &'static str {
534        use NotableTraitColor::*;
535        match color {
536            Grey => "grey",
537            Red => "red",
538            Green => "green",
539            Yellow => "yellow",
540            Blue => "blue",
541            Magenta => "magenta",
542            Cyan => "cyan",
543            Transparent => "transparent",
544        }
545    }
546}
547
548impl std::fmt::Display for NotableTraitColor {
549    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
550        f.write_str((*self).into())
551    }
552}
553
554impl<E: rustc_span::SpanEncoder> rustc_serialize::Encodable<E> for DocAttribute {
555    fn encode(&self, encoder: &mut E) {
556        let DocAttribute {
557            first_span,
558            aliases,
559            hidden,
560            inline,
561            cfg,
562            auto_cfg,
563            auto_cfg_change,
564            fake_variadic,
565            keyword,
566            attribute,
567            masked,
568            notable_trait,
569            search_unbox,
570            html_favicon_url,
571            html_logo_url,
572            html_playground_url,
573            html_root_url,
574            html_no_source,
575            issue_tracker_base_url,
576            rust_logo,
577            test_attrs,
578            no_crate_inject,
579        } = self;
580        rustc_serialize::Encodable::<E>::encode(first_span, encoder);
581        rustc_serialize::Encodable::<E>::encode(aliases, encoder);
582        rustc_serialize::Encodable::<E>::encode(hidden, encoder);
583
584        // FIXME: The `doc(inline)` attribute is never encoded, but is it actually the right thing
585        // to do? I suspect the condition was broken, should maybe instead not encode anything if we
586        // have `doc(no_inline)`.
587        let inline = inline.filter(|(i, _)| *i != DocInline::Inline);
588        rustc_serialize::Encodable::<E>::encode(&inline, encoder);
589
590        rustc_serialize::Encodable::<E>::encode(cfg, encoder);
591        rustc_serialize::Encodable::<E>::encode(auto_cfg, encoder);
592        rustc_serialize::Encodable::<E>::encode(auto_cfg_change, encoder);
593        rustc_serialize::Encodable::<E>::encode(fake_variadic, encoder);
594        rustc_serialize::Encodable::<E>::encode(keyword, encoder);
595        rustc_serialize::Encodable::<E>::encode(attribute, encoder);
596        rustc_serialize::Encodable::<E>::encode(masked, encoder);
597        rustc_serialize::Encodable::<E>::encode(notable_trait, encoder);
598        rustc_serialize::Encodable::<E>::encode(search_unbox, encoder);
599        rustc_serialize::Encodable::<E>::encode(html_favicon_url, encoder);
600        rustc_serialize::Encodable::<E>::encode(html_logo_url, encoder);
601        rustc_serialize::Encodable::<E>::encode(html_playground_url, encoder);
602        rustc_serialize::Encodable::<E>::encode(html_root_url, encoder);
603        rustc_serialize::Encodable::<E>::encode(html_no_source, encoder);
604        rustc_serialize::Encodable::<E>::encode(issue_tracker_base_url, encoder);
605        rustc_serialize::Encodable::<E>::encode(rust_logo, encoder);
606        rustc_serialize::Encodable::<E>::encode(test_attrs, encoder);
607        rustc_serialize::Encodable::<E>::encode(no_crate_inject, encoder);
608    }
609}
610
611#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcShowSpansKind {
    #[inline]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self {
        match self {
            Self::Expr => RustcShowSpansKind::Expr,
            Self::Ty => RustcShowSpansKind::Ty,
            Self::Path => RustcShowSpansKind::Path,
            Self::GenericArgs => RustcShowSpansKind::GenericArgs,
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcShowSpansKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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",
                RustcShowSpansKind::GenericArgs => "GenericArgs",
            })
    }
}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),
                    RustcShowSpansKind::GenericArgs =>
                        3u8.stable_hash(__hcx, __hasher),
                }
                match *self {
                    RustcShowSpansKind::Expr => {}
                    RustcShowSpansKind::Ty => {}
                    RustcShowSpansKind::Path => {}
                    RustcShowSpansKind::GenericArgs => {}
                }
            }
        }
    };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 }
                        RustcShowSpansKind::GenericArgs => { 3usize }
                    };
                ::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 }
                    3usize => { RustcShowSpansKind::GenericArgs }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcShowSpansKind`, expected 0..4, 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") }
                    Self::GenericArgs => { __p.word("GenericArgs") }
                }
            }
        }
    };PrintAttribute)]
612pub enum RustcShowSpansKind {
613    Expr,
614    Ty,
615    Path,
616    GenericArgs,
617}
618
619#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcDumpLayoutKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
620pub enum RustcDumpLayoutKind {
621    Align,
622    BackendRepr,
623    Debug,
624    HomogenousAggregate,
625    LargestNiche,
626    Size,
627}
628
629#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcMirKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
630pub enum RustcMirKind {
631    PrettyLiveLocals,
632    PrettyPreciseLiveness,
633    PrettyTransitiveLiveLocals,
634    PeekMaybeInit,
635    PeekMaybeUninit,
636    PeekLiveness,
637    StopAfterDataflow,
638    BorrowckGraphvizPostflow { path: PathBuf },
639    BorrowckGraphvizFormat { format: BorrowckGraphvizFormatKind },
640}
641
642#[derive(#[automatically_derived]impl ::core::clone::Clone for
    BorrowckGraphvizFormatKind {
    #[inline]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { BorrowckGraphvizFormatKind::TwoPhase }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for BorrowckGraphvizFormatKind
    {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
643pub enum BorrowckGraphvizFormatKind {
644    TwoPhase,
645}
646
647#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanAttribute {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
648#[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)]
649pub struct RustcCleanAttribute {
650    pub span: Span,
651    pub cfg: Symbol,
652    pub except: Option<RustcCleanQueries>,
653    pub loaded_from_disk: Option<RustcCleanQueries>,
654}
655
656/// Represents the `except=` or `loaded_from_disk=` argument of `#[rustc_clean]`
657#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanQueries {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
658#[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)]
659pub struct RustcCleanQueries {
660    pub entries: ThinVec<Symbol>,
661    pub span: Span,
662}
663
664#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcAutodiff {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
665#[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)]
666pub struct RustcAutodiff {
667    /// Conceptually either forward or reverse mode AD, as described in various autodiff papers and
668    /// e.g. in the [JAX
669    /// Documentation](https://jax.readthedocs.io/en/latest/_tutorials/advanced-autodiff.html#how-it-s-made-two-foundational-autodiff-functions).
670    pub mode: DiffMode,
671    /// A user-provided, batching width. If not given, we will default to 1 (no batching).
672    /// Calling a differentiated, non-batched function through a loop 100 times is equivalent to:
673    /// - Calling the function 50 times with a batch size of 2
674    /// - Calling the function 25 times with a batch size of 4,
675    /// etc. A batched function takes more (or longer) arguments, and might be able to benefit from
676    /// cache locality, better re-usal of primal values, and other optimizations.
677    /// We will (before LLVM's vectorizer runs) just generate most LLVM-IR instructions `width`
678    /// times, so this massively increases code size. As such, values like 1024 are unlikely to
679    /// work. We should consider limiting this to u8 or u16, but will leave it at u32 for
680    /// experiments for now and focus on documenting the implications of a large width.
681    pub width: u32,
682    pub input_activity: ThinVec<DiffActivity>,
683    pub ret_activity: DiffActivity,
684}
685
686impl RustcAutodiff {
687    pub fn has_primal_ret(&self) -> bool {
688        #[allow(non_exhaustive_omitted_patterns)] match self.ret_activity {
    DiffActivity::Active | DiffActivity::Dual => true,
    _ => false,
}matches!(self.ret_activity, DiffActivity::Active | DiffActivity::Dual)
689    }
690}
691
692impl RustcAutodiff {
693    pub fn has_ret_activity(&self) -> bool {
694        self.ret_activity != DiffActivity::None
695    }
696    pub fn has_active_only_ret(&self) -> bool {
697        self.ret_activity == DiffActivity::ActiveOnly
698    }
699
700    pub fn error() -> Self {
701        RustcAutodiff {
702            mode: DiffMode::Error,
703            width: 0,
704            ret_activity: DiffActivity::None,
705            input_activity: ThinVec::new(),
706        }
707    }
708
709    pub fn source() -> Self {
710        RustcAutodiff {
711            mode: DiffMode::Source,
712            width: 0,
713            ret_activity: DiffActivity::None,
714            input_activity: ThinVec::new(),
715        }
716    }
717
718    pub fn is_active(&self) -> bool {
719        self.mode != DiffMode::Error
720    }
721
722    pub fn is_source(&self) -> bool {
723        self.mode == DiffMode::Source
724    }
725    pub fn apply_autodiff(&self) -> bool {
726        !#[allow(non_exhaustive_omitted_patterns)] match self.mode {
    DiffMode::Error | DiffMode::Source => true,
    _ => false,
}matches!(self.mode, DiffMode::Error | DiffMode::Source)
727    }
728
729    pub fn into_item(
730        self,
731        source: String,
732        target: String,
733        inputs: Vec<TypeTree>,
734        output: TypeTree,
735    ) -> AutoDiffItem {
736        AutoDiffItem { source, target, inputs, output, attrs: self }
737    }
738}
739
740/// We generate one of these structs for each `#[autodiff(...)]` attribute.
741#[derive(#[automatically_derived]impl ::core::clone::Clone for AutoDiffItem {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
742pub struct AutoDiffItem {
743    /// The name of the function getting differentiated
744    pub source: String,
745    /// The name of the function being generated
746    pub target: String,
747    pub attrs: RustcAutodiff,
748    pub inputs: Vec<TypeTree>,
749    pub output: TypeTree,
750}
751
752impl fmt::Display for AutoDiffItem {
753    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
754        f.write_fmt(format_args!("Differentiating {0} -> {1}", self.source,
        self.target))write!(f, "Differentiating {} -> {}", self.source, self.target)?;
755        f.write_fmt(format_args!(" with attributes: {0:?}", self.attrs))write!(f, " with attributes: {:?}", self.attrs)?;
756        f.write_fmt(format_args!(" with inputs: {0:?}", self.inputs))write!(f, " with inputs: {:?}", self.inputs)?;
757        f.write_fmt(format_args!(" with output: {0:?}", self.output))write!(f, " with output: {:?}", self.output)
758    }
759}
760
761#[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]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcAssertVarianceKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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)]
762#[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)]
763pub enum RustcAssertVarianceKind {
764    Covariant,
765    Invariant,
766    Contravariant,
767    Bivariant,
768}
769
770#[derive(#[automatically_derived]impl ::core::clone::Clone for UnstableRemovedFeature {
    #[inline]
    #[rustc_trivial_field_reads]
    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]
    #[rustc_trivial_field_reads]
    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)]
771pub struct UnstableRemovedFeature {
772    pub feature: Symbol,
773    pub reason: Symbol,
774    pub link: Symbol,
775    pub since: RustcVersion,
776}
777
778/// Represents parsed *built-in* inert attributes.
779///
780/// ## Overview
781/// These attributes are markers that guide the compilation process and are never expanded into other code.
782/// They persist throughout the compilation phases, from AST to HIR and beyond.
783///
784/// ## Attribute Processing
785/// While attributes are initially parsed by [`rustc_parse`] into [`ast::Attribute`], they still contain raw token streams
786/// because different attributes have different internal structures. This enum represents the final,
787/// fully parsed form of these attributes, where each variant contains all the information and
788/// structure relevant for the specific attribute.
789///
790/// Some attributes can be applied multiple times to the same item, and they are "collapsed" into a single
791/// semantic attribute. For example:
792/// ```rust
793/// #[repr(C)]
794/// #[repr(packed)]
795/// struct S { }
796/// ```
797/// This is equivalent to `#[repr(C, packed)]` and results in a single [`AttributeKind::Repr`] containing
798/// both `C` and `packed` annotations. This collapsing happens during parsing and is reflected in the
799/// data structures defined in this enum.
800///
801/// ## Usage
802/// These parsed attributes are used throughout the compiler to:
803/// - Control code generation (e.g., `#[repr]`)
804/// - Mark API stability (`#[stable]`, `#[unstable]`)
805/// - Provide documentation (`#[doc]`)
806/// - Guide compiler behavior (e.g., `#[allow_internal_unstable]`)
807///
808/// ## Note on Attribute Organization
809/// Some attributes like `InlineAttr`, `OptimizeAttr`, and `InstructionSetAttr` are defined separately
810/// from this enum because they are used in specific compiler phases (like code generation) and don't
811/// need to persist throughout the entire compilation process. They are typically processed and
812/// converted into their final form earlier in the compilation pipeline.
813///
814/// For example:
815/// - `InlineAttr` is used during code generation to control function inlining
816/// - `OptimizeAttr` is used to control optimization levels
817/// - `InstructionSetAttr` is used for target-specific code generation
818///
819/// These attributes are handled by their respective compiler passes in the [`rustc_codegen_ssa`] crate
820/// and don't need to be preserved in the same way as the attributes in this enum.
821///
822/// For more details on attribute parsing, see the [`rustc_attr_parsing`] crate.
823///
824/// [`rustc_parse`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/index.html
825/// [`rustc_codegen_ssa`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/index.html
826/// [`rustc_attr_parsing`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_attr_parsing/index.html
827#[derive(#[automatically_derived]impl ::core::clone::Clone for AttributeKind {
    #[inline]
    #[rustc_trivial_field_reads]
    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::MustNotSuspend { reason: __self_0 } =>
                AttributeKind::MustNotSuspend {
                    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 { llvm: __self_0 } =>
                AttributeKind::RustcIntrinsic {
                    llvm: ::core::clone::Clone::clone(__self_0),
                },
            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::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::RustcTestEntrypointMarker =>
                AttributeKind::RustcTestEntrypointMarker,
            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(__self_0) =>
                AttributeKind::RustcTrivialFieldReads(::core::clone::Clone::clone(__self_0)),
            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]
    #[rustc_trivial_field_reads]
    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::MustNotSuspend { reason: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "MustNotSuspend 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 { llvm: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcIntrinsic llvm", &__self_0),
            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::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::RustcTestEntrypointMarker =>
                ::core::fmt::Formatter::write_str(f,
                    "RustcTestEntrypointMarker"),
            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(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "RustcTrivialFieldReads", &__self_0),
            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::MustNotSuspend { 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 { llvm: ref __binding_0 } =>
                        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::RustcShowSpans(ref __binding_0) =>
                        171u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
                        => 172u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcSkipDuringMethodDispatch {
                        array: ref __binding_0, boxed_slice: ref __binding_1 } =>
                        173u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcSpecializationTrait =>
                        174u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcStdInternalSymbol =>
                        175u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcStrictCoherence(ref __binding_0) =>
                        176u8.stable_hash(__hcx, __hasher),
                    AttributeKind::RustcTestEntrypointMarker =>
                        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(ref __binding_0) =>
                        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::MustNotSuspend { 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 { llvm: ref __binding_0 } => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    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::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::RustcTestEntrypointMarker => {}
                    AttributeKind::RustcTestMarker(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    AttributeKind::RustcTrivialFieldReads(ref __binding_0) => {
                        { __binding_0.stable_hash(__hcx, __hasher); }
                    }
                    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::MustNotSuspend { 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 { llvm: ref __binding_0 } => {
                            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::RustcShowSpans(ref __binding_0) => {
                            171usize
                        }
                        AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
                            => {
                            172usize
                        }
                        AttributeKind::RustcSkipDuringMethodDispatch {
                            array: ref __binding_0, boxed_slice: ref __binding_1 } => {
                            173usize
                        }
                        AttributeKind::RustcSpecializationTrait => { 174usize }
                        AttributeKind::RustcStdInternalSymbol => { 175usize }
                        AttributeKind::RustcStrictCoherence(ref __binding_0) => {
                            176usize
                        }
                        AttributeKind::RustcTestEntrypointMarker => { 177usize }
                        AttributeKind::RustcTestMarker(ref __binding_0) => {
                            178usize
                        }
                        AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
                            179usize
                        }
                        AttributeKind::RustcTrivialFieldReads(ref __binding_0) => {
                            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::MustNotSuspend { 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 { llvm: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    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::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::RustcTestEntrypointMarker => {}
                    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(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    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::MustNotSuspend {
                            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 {
                            llvm: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    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::RustcShowSpans(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    172usize => {
                        AttributeKind::RustcSimdMonomorphizeLaneLimit(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    173usize => {
                        AttributeKind::RustcSkipDuringMethodDispatch {
                            array: ::rustc_serialize::Decodable::decode(__decoder),
                            boxed_slice: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    174usize => { AttributeKind::RustcSpecializationTrait }
                    175usize => { AttributeKind::RustcStdInternalSymbol }
                    176usize => {
                        AttributeKind::RustcStrictCoherence(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    177usize => { AttributeKind::RustcTestEntrypointMarker }
                    178usize => {
                        AttributeKind::RustcTestMarker(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    179usize => {
                        AttributeKind::RustcThenThisWouldNeed(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    180usize => {
                        AttributeKind::RustcTrivialFieldReads(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    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::MustNotSuspend { reason } => {
                        __p.word("MustNotSuspend");
                        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 { llvm } => {
                        __p.word("RustcIntrinsic");
                        if true && !llvm.should_render() { return; }
                        __p.nbsp();
                        __p.word("{");
                        let mut __printed_anything = false;
                        if llvm.should_render() {
                            if __printed_anything { __p.word_space(","); }
                            __p.word("llvm");
                            __p.word(":");
                            __p.nbsp();
                            __printed_anything = true;
                        }
                        llvm.print_attribute(__p);
                        __p.word("}");
                    }
                    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::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::RustcTestEntrypointMarker => {
                        __p.word("RustcTestEntrypointMarker")
                    }
                    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(f0) => {
                        __p.word("RustcTrivialFieldReads");
                        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::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)]
828pub enum AttributeKind {
829    // tidy-alphabetical-start
830    /// Represents `#[allow_internal_unsafe]`.
831    AllowInternalUnsafe(Span),
832
833    /// Represents `#[allow_internal_unstable]`.
834    AllowInternalUnstable(ThinVec<(Symbol, Span)>, Span),
835
836    /// Represents `#[rustc_always_gca]`
837    AlwaysGca,
838
839    /// Represents `#[automatically_derived]`
840    AutomaticallyDerived,
841
842    /// Represents the trace attribute of `#[cfg_attr]`
843    CfgAttrTrace(ThinVec<(CfgEntry, Span)>),
844
845    /// Represents the trace attribute of `#[cfg]`
846    CfgTrace(ThinVec<(CfgEntry, Span)>),
847
848    /// Represents `#[cfi_encoding]`
849    CfiEncoding {
850        encoding: Symbol,
851    },
852
853    /// Represents `#[cold]`.
854    Cold,
855
856    /// Represents `#[collapse_debuginfo]`.
857    CollapseDebugInfo(CollapseMacroDebuginfo),
858
859    /// Represents `#[compiler_builtins]`.
860    CompilerBuiltins,
861
862    /// Represents `#[const_continue]`.
863    ConstContinue(Span),
864
865    /// Represents `#[coroutine]`.
866    ///
867    /// This attribute can be applied to closures to make them coroutines instead.
868    Coroutine,
869
870    /// Represents `#[coverage(..)]`.
871    Coverage(CoverageAttrKind),
872
873    /// Represents `#[crate_name = ...]`
874    CrateName {
875        name: Symbol,
876        name_span: Span,
877        attr_span: Span,
878    },
879
880    /// Represents `#![crate_type = ...]`
881    CrateType(ThinVec<CrateType>),
882
883    /// Represents `#[custom_mir]`.
884    CustomMir(Option<(MirDialect, Span)>, Option<(MirPhase, Span)>),
885
886    /// Represents `#[debugger_visualizer]`.
887    DebuggerVisualizer(ThinVec<DebugVisualizer>),
888
889    /// Represents `#![default_lib_allocator]`
890    DefaultLibAllocator,
891
892    /// Represents [`#[deprecated]`](https://doc.rust-lang.org/stable/reference/attributes/diagnostics.html#the-deprecated-attribute).
893    Deprecated {
894        deprecation: Deprecation,
895        span: Span,
896        /// `true` if this an inner attribute (ie `#![]`).
897        is_inner: bool,
898    },
899
900    /// Represents `#[diagnostic::do_not_recommend]`.
901    DoNotRecommend,
902
903    /// Represents [`#[doc]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html).
904    /// Represents all other uses of the [`#[doc]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html)
905    /// attribute.
906    Doc(Box<DocAttribute>),
907
908    /// Represents specifically [`#[doc = "..."]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html).
909    /// i.e. doc comments.
910    DocComment {
911        style: AttrStyle,
912        kind: DocFragmentKind,
913        span: Span,
914        comment: Symbol,
915    },
916
917    /// Implementation detail of `#[eii]`
918    EiiDeclaration(EiiDecl),
919
920    /// Implementation detail of `#[eii]`
921    EiiImpl(Box<EiiImpl>),
922
923    /// Represents [`#[export_name]`](https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute).
924    ExportName {
925        /// The name to export this item with.
926        /// It may not contain \0 bytes as it will be converted to a null-terminated string.
927        name: Symbol,
928        span: Span,
929    },
930
931    /// Represents `#[export_stable]`.
932    ExportStable,
933
934    /// Represents `#[feature(...)]`
935    Feature(ThinVec<Ident>, Span),
936
937    /// Represents `#[ffi_const]`.
938    FfiConst,
939
940    /// Represents `#[ffi_pure]`.
941    FfiPure(Span),
942
943    /// Represents `#[fundamental]`.
944    Fundamental,
945
946    /// Represents `#[ignore]`
947    Ignore {
948        span: Span,
949        /// ignore can optionally have a reason: `#[ignore = "reason this is ignored"]`
950        reason: Option<Symbol>,
951    },
952
953    /// Represents `#[inline]` and `#[rustc_force_inline]`.
954    Inline(InlineAttr, Span),
955
956    /// Represents `#[instruction_set]`
957    InstructionSet(InstructionSetAttr),
958
959    /// Represents `#[instrument_fn]`
960    InstrumentFn(InstrumentFnAttr),
961
962    /// Represents `#[lang]`
963    Lang(LangItem),
964
965    /// Represents `#[link]`.
966    Link(ThinVec<LinkEntry>, Span),
967
968    /// Represents `#[link_name]`.
969    LinkName {
970        name: Symbol,
971        span: Span,
972    },
973
974    /// Represents `#[link_ordinal]`.
975    LinkOrdinal {
976        ordinal: u16,
977        span: Span,
978    },
979
980    /// Represents [`#[link_section]`](https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute)
981    LinkSection {
982        name: Symbol,
983    },
984
985    /// Represents `#[linkage]`.
986    Linkage(Linkage, Span),
987
988    /// Represents `#[lint::as_ptr]` (used by the `dangling_pointers_from_temporaries` lint).
989    LintAsPtr,
990
991    /// Represents `#[allow]`, `#[warn]`, `#[deny]`, `#[forbid]`, and `#[expect]`.
992    LintCheck(ThinVec<LintCheck>),
993
994    /// Represents `#[lint::never_returns_null_ptr]` (used by the `useless_ptr_null_checks` lint).
995    LintNeverReturnsNullPtr,
996
997    /// Represents `#[lint::should_not_be_called_on_const_items]` (used by the
998    /// `const_item_interior_mutations` lint).
999    LintShouldNotBeCalledOnConstItems,
1000
1001    /// Represents `#[loop_match]`.
1002    LoopMatch(Span),
1003
1004    /// Represents `#[macro_escape]`.
1005    MacroEscape,
1006
1007    /// Represents [`#[macro_export]`](https://doc.rust-lang.org/reference/macros-by-example.html#r-macro.decl.scope.path).
1008    MacroExport {
1009        span: Span,
1010        local_inner_macros: bool,
1011    },
1012
1013    /// Represents `#[macro_use]`.
1014    MacroUse {
1015        span: Span,
1016        arguments: MacroUseArgs,
1017    },
1018
1019    /// Represents `#[marker]`.
1020    Marker,
1021
1022    /// Represents [`#[may_dangle]`](https://std-dev-guide.rust-lang.org/tricky/may-dangle.html).
1023    MayDangle(Span),
1024
1025    /// Represents `#[move_size_limit]`
1026    MoveSizeLimit {
1027        limit: Limit,
1028    },
1029
1030    /// Represents `#[must_not_suspend]`
1031    MustNotSuspend {
1032        reason: Option<Symbol>,
1033    },
1034
1035    /// Represents `#[must_use]`.
1036    MustUse {
1037        /// Used by `clippy`.
1038        span: Span,
1039        /// must_use can optionally have a reason: `#[must_use = "reason this must be used"]`
1040        reason: Option<Symbol>,
1041    },
1042
1043    /// Represents `#[naked]`
1044    Naked(Span),
1045
1046    /// Represents `#[needs_allocator]`
1047    NeedsAllocator,
1048
1049    /// Represents `#[needs_panic_runtime]`
1050    NeedsPanicRuntime,
1051
1052    /// Represents `#[no_builtins]`
1053    NoBuiltins,
1054
1055    /// Represents `#[no_core]`
1056    NoCore,
1057
1058    /// Represents `#[no_implicit_prelude]`
1059    NoImplicitPrelude,
1060
1061    /// Represents `#[no_link]`
1062    NoLink,
1063
1064    /// Represents `#[no_main]`
1065    NoMain,
1066
1067    /// Represents `#[no_mangle]`
1068    NoMangle(Span),
1069
1070    /// Represents `#[no_std]`
1071    NoStd,
1072
1073    /// Represents `#[non_exhaustive]`
1074    NonExhaustive(Span),
1075
1076    /// Represents `#[diagnostic::on_const]`.
1077    OnConst {
1078        /// The attribute path span.
1079        span: Span,
1080        /// None if the directive was malformed in some way.
1081        directive: Option<Box<Directive>>,
1082    },
1083
1084    /// Represents `#[diagnostic::on_move]`
1085    OnMove {
1086        directive: Option<Box<Directive>>,
1087    },
1088
1089    /// Represents`#[diagnostic::on_type_error]`.
1090    OnTypeError {
1091        span: Span,
1092        directive: Option<Box<Directive>>,
1093    },
1094
1095    /// Represents `#[rustc_on_unimplemented]` and `#[diagnostic::on_unimplemented]`.
1096    OnUnimplemented {
1097        /// None if the directive was malformed in some way.
1098        directive: Option<Box<Directive>>,
1099    },
1100
1101    /// Represents `#[diagnostic::on_unknown]`
1102    OnUnknown {
1103        /// None if the directive was malformed in some way.
1104        directive: Option<Box<Directive>>,
1105    },
1106
1107    /// Represents `#[diagnostic::on_unmatched_args]`.
1108    OnUnmatchedArgs {
1109        /// None if the directive was malformed in some way.
1110        directive: Option<Box<Directive>>,
1111    },
1112
1113    /// Represents `#[diagnostic::opaque]`.
1114    Opaque,
1115
1116    /// Represents `#[optimize(size|speed)]`
1117    Optimize(OptimizeAttr, Span),
1118
1119    /// Represents `#[panic_runtime]`
1120    PanicRuntime,
1121
1122    /// Represents `#[patchable_function_entry]`
1123    PatchableFunctionEntry {
1124        prefix: Option<u8>,
1125        entry: Option<u8>,
1126        section: Option<Symbol>,
1127    },
1128
1129    /// Represents `#[path]`
1130    Path(Symbol, Span),
1131
1132    /// Represents `#[pattern_complexity_limit]`
1133    PatternComplexityLimit {
1134        limit: Limit,
1135    },
1136
1137    /// Represents `#[pin_v2]`.
1138    ///
1139    /// The `#[pin_v2]` attribute is part of the `pin_ergonomics` experiment that allows
1140    /// structurally pinning, tracked in <https://github.com/rust-lang/rust/issues/130494>.
1141    PinV2(Span),
1142
1143    /// Represents `#[prelude_import]`
1144    PreludeImport,
1145
1146    /// Represents `#[proc_macro]`
1147    ProcMacro,
1148
1149    /// Represents `#[proc_macro_attribute]`
1150    ProcMacroAttribute,
1151
1152    /// Represents `#[proc_macro_derive]`
1153    ProcMacroDerive {
1154        trait_name: Symbol,
1155        helper_attrs: ThinVec<Symbol>,
1156    },
1157
1158    /// Represents `#[profiler_runtime]`
1159    ProfilerRuntime,
1160
1161    /// Represents [`#[recursion_limit]`](https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute)
1162    RecursionLimit {
1163        limit: Limit,
1164    },
1165
1166    /// Represents `#[reexport_test_harness_main]`
1167    ReexportTestHarnessMain(Symbol),
1168
1169    /// Represents `#[register_attribute_tool]`, `#[register_lint_tool]` and `#[register_tool]`
1170    RegisterTool {
1171        attr_tools: ThinVec<(Ident, ToolOptions)>,
1172        lint_tools: ThinVec<(Ident, ToolOptions)>,
1173    },
1174
1175    /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
1176    Repr {
1177        reprs: ThinVec<(ReprAttr, Span)>,
1178        first_span: Span,
1179    },
1180
1181    /// Represents `#[rustc_abi(..)]`
1182    RustcAbi {
1183        attr_span: Span,
1184        kind: RustcAbiAttrKind,
1185    },
1186
1187    /// Represents `#[rustc_align(N)]`.
1188    ///
1189    /// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
1190    RustcAlign {
1191        align: Align,
1192        span: Span,
1193    },
1194
1195    /// Represents `#[rustc_allocator]`
1196    RustcAllocator,
1197
1198    /// Represents `#[rustc_allocator_zeroed]`
1199    RustcAllocatorZeroed,
1200
1201    /// Represents `#[rustc_allocator_zeroed_variant]`
1202    RustcAllocatorZeroedVariant {
1203        name: Symbol,
1204    },
1205
1206    /// Represents `#[rustc_allow_const_fn_unstable]`.
1207    RustcAllowConstFnUnstable(ThinVec<Symbol>, Span),
1208
1209    /// Represents `#[rustc_allow_incoherent_impl]`.
1210    RustcAllowIncoherentImpl(Span),
1211
1212    /// Represents `#[rustc_allow_lifetime_dependent_specialization]`.
1213    RustcAllowLifetimeDependentSpecialization,
1214
1215    /// Represents `#[rustc_assert_variance]`.
1216    RustcAssertVariance {
1217        span: Span,
1218        kind: RustcAssertVarianceKind,
1219    },
1220
1221    /// Represents `#[rustc_autodiff]`.
1222    RustcAutodiff(Option<Box<RustcAutodiff>>),
1223
1224    /// Represents `#[rustc_default_body_unstable]`.
1225    RustcBodyStability {
1226        stability: DefaultBodyStability,
1227        /// Span of the `#[rustc_default_body_unstable(...)]` attribute
1228        span: Span,
1229    },
1230    /// Represents `#[rustc_builtin_macro]`.
1231    RustcBuiltinMacro {
1232        builtin_name: Option<Symbol>,
1233        helper_attrs: ThinVec<Symbol>,
1234    },
1235
1236    /// Represents `#[rustc_canonical_symbol]`
1237    RustcCanonicalSymbol,
1238
1239    /// Represents `#[rustc_capture_analysis]`
1240    RustcCaptureAnalysis,
1241
1242    /// Represents `#[rustc_expected_cgu_reuse]`, `#[rustc_partition_codegened]` and `#[rustc_partition_reused]`.
1243    RustcCguTestAttr(ThinVec<(Span, CguFields)>),
1244
1245    /// Represents `#[rustc_clean]`
1246    RustcClean(ThinVec<RustcCleanAttribute>),
1247
1248    /// Represents `#[rustc_coherence_is_core]`
1249    RustcCoherenceIsCore,
1250
1251    /// Represents `#[rustc_coinductive]`.
1252    RustcCoinductive,
1253
1254    /// Represents the [`rustc_comptime`](./attribute.rustc_comptime.html) attribute.
1255    RustcComptime(Span),
1256
1257    /// Represents `#[rustc_confusables]`.
1258    RustcConfusables {
1259        confusables: ThinVec<Symbol>,
1260    },
1261    /// Represents `#[rustc_const_stable]` and `#[rustc_const_unstable]`.
1262    RustcConstStability {
1263        stability: PartialConstStability,
1264        /// Path span of the `#[rustc_const_stable(...)]` or `#[rustc_const_unstable(...)]`
1265        /// attribute.
1266        span: Span,
1267    },
1268
1269    /// Represents `#[rustc_const_stable_indirect]`.
1270    RustcConstStableIndirect,
1271
1272    /// Represents `#[rustc_conversion_suggestion]`.
1273    ///
1274    /// Enumerates "identity-like" conversion methods to suggest on type mismatch.
1275    RustcConversionSuggestion,
1276
1277    /// Represents `#[rustc_deallocator]`
1278    RustcDeallocator,
1279
1280    /// Represents `#[rustc_delayed_bug_from_inside_query]`
1281    RustcDelayedBugFromInsideQuery,
1282
1283    /// Represents `#[rustc_deny_explicit_impl]`.
1284    RustcDenyExplicitImpl,
1285
1286    /// Represents `#[rustc_deprecated_safe_2024]`
1287    RustcDeprecatedSafe2024 {
1288        suggestion: Symbol,
1289    },
1290    /// Represents `#[rustc_diagnostic_item]`
1291    RustcDiagnosticItem(Symbol),
1292
1293    /// Represents `#[rustc_do_not_const_check]`.
1294    ///
1295    /// Functions with this attribute will not have their body const-checked. It will always get
1296    /// replaced during CTFE via `hook_special_const_fn`.
1297    RustcDoNotConstCheck,
1298
1299    /// Represents `#[rustc_doc_primitive = ...]`
1300    RustcDocPrimitive(Span, Symbol),
1301
1302    /// Represents `#[rustc_dummy]`.
1303    RustcDummy,
1304
1305    /// Represents the [`rustc_dump_clauses`](./attribute.rustc_dump_clauses.html) attribute.
1306    RustcDumpClauses,
1307
1308    /// Represents the [`rustc_dump_def_parents`](./attribute.rustc_dump_def_parents.html) attribute.
1309    RustcDumpDefParents,
1310
1311    /// Represents the [`rustc_dump_def_path`](./attribute.rustc_dump_def_path.html) attribute.
1312    RustcDumpDefPath(Span),
1313
1314    /// Represents the [`rustc_dump_generics`](./attribute.rustc_dump_generics.html) attribute.
1315    RustcDumpGenerics,
1316
1317    /// Represents the [`rustc_dump_hidden_type_of_opaques`](./attribute.rustc_dump_hidden_type_of_opaques.html) attribute.
1318    RustcDumpHiddenTypeOfOpaques,
1319
1320    /// Represents the [`rustc_dump_inferred_outlives`](./attribute.rustc_dump_inferred_outlives.html) attribute.
1321    RustcDumpInferredOutlives,
1322
1323    /// Represents the [`rustc_dump_item_bounds`](./attribute.rustc_dump_item_bounds.html) attribute.
1324    RustcDumpItemBounds,
1325
1326    /// Represents the [`rustc_dump_layout`](./attribute.rustc_dump_layout.html) attribute.
1327    RustcDumpLayout(ThinVec<RustcDumpLayoutKind>),
1328
1329    /// Represents the [`rustc_dump_object_lifetime_defaults`](./attribute.rustc_dump_object_lifetime_defaults.html) attribute.
1330    RustcDumpObjectLifetimeDefaults,
1331
1332    /// Represents the [`rustc_dump_symbol_name`](./attribute.rustc_dump_symbol_name.html) attribute.
1333    RustcDumpSymbolName(Span),
1334
1335    /// Represents `#[rustc_dump_user_args]`
1336    RustcDumpUserArgs,
1337
1338    /// Represents the [`rustc_dump_variances`](./attribute.rustc_dump_variances.html) attribute.
1339    RustcDumpVariances,
1340
1341    /// Represents the [`rustc_dump_variances_of_opaques`](./attribute.rustc_dump_variances_of_opaques.html) attribute.
1342    RustcDumpVariancesOfOpaques,
1343
1344    /// Represents the [`rustc_dump_vtable`](./attribute.rustc_dump_vtable.html) attribute.
1345    RustcDumpVtable(Span),
1346
1347    /// Represents the [`rustc_dyn_incompatible_trait`](./attribute.rustc_dyn_incompatible_trait.html) attribute.
1348    RustcDynIncompatibleTrait(Span),
1349
1350    /// Represents `#[rustc_effective_visibility]`.
1351    RustcEffectiveVisibility,
1352
1353    /// Implementation detail of `#[eii]`
1354    RustcEiiForeignItem,
1355
1356    /// Represents `#[rustc_evaluate_where_clauses]`
1357    RustcEvaluateWhereClauses,
1358
1359    RustcHasIncoherentInherentImpls,
1360
1361    /// Represents `#[rustc_if_this_changed]`
1362    RustcIfThisChanged(Span, Option<Symbol>),
1363
1364    /// Represents `#[rustc_inherit_overflow_checks]`
1365    RustcInheritOverflowChecks,
1366
1367    /// Represents `#[rustc_insignificant_dtor]`
1368    RustcInsignificantDtor,
1369
1370    /// Represents `#[rustc_intrinsic]` / `#[rustc_intrinsic(llvm = "...")]`
1371    RustcIntrinsic {
1372        llvm: Option<Symbol>,
1373    },
1374
1375    /// Represents `#[rustc_intrinsic_const_stable_indirect]`
1376    RustcIntrinsicConstStableIndirect,
1377
1378    /// Represents `#[rustc_legacy_const_generics]`
1379    RustcLegacyConstGenerics {
1380        fn_indexes: ThinVec<(usize, Span)>,
1381        attr_span: Span,
1382    },
1383
1384    /// Represents `#[rustc_lint_opt_deny_field_access]`.
1385    ///
1386    /// Used by the `rustc::bad_opt_access` lint on fields
1387    /// types (as well as any others in future).
1388    RustcLintOptDenyFieldAccess {
1389        lint_message: Symbol,
1390    },
1391
1392    /// Represents `#[rustc_lint_opt_ty]`.
1393    ///
1394    /// Used by the `rustc::bad_opt_access` lint to identify `DebuggingOptions` and `CodegenOptions`
1395    /// types (as well as any others in future)
1396    RustcLintOptTy,
1397
1398    /// Represents `#[rustc_lint_query_instability]`.
1399    ///
1400    /// Used by the `rustc::potential_query_instability` lint to warn methods which
1401    /// might not be stable during incremental compilation.
1402    RustcLintQueryInstability,
1403
1404    /// Represents `#[rustc_lint_untracked_query_information]`.
1405    ///
1406    /// Used by the `rustc::untracked_query_information` lint to warn methods which
1407    /// might not be stable during incremental compilation.
1408    RustcLintUntrackedQueryInformation,
1409
1410    /// Represents `#[rustc_macro_transparency]`.
1411    RustcMacroTransparency(Transparency),
1412
1413    /// Represents `#[rustc_main]`.
1414    RustcMain,
1415
1416    /// Represents `#[rustc_mir]`.
1417    RustcMir(ThinVec<RustcMirKind>),
1418
1419    /// Represents `#[rustc_must_implement_one_of]`
1420    RustcMustImplementOneOf {
1421        attr_span: Span,
1422        fn_names: ThinVec<Ident>,
1423    },
1424
1425    /// Represents `#[rustc_must_match_exhaustively]`
1426    RustcMustMatchExhaustively(Span),
1427
1428    /// Represents `#[rustc_no_implicit_autorefs]`
1429    RustcNoImplicitAutorefs,
1430
1431    /// Represents `#[rustc_no_implicit_bounds]`
1432    RustcNoImplicitBounds,
1433
1434    /// Represents `#[rustc_no_mir_inline]`
1435    RustcNoMirInline,
1436
1437    /// Represents `#[rustc_no_writable]`
1438    RustcNoWritable,
1439
1440    /// Represents `#[rustc_non_const_trait_method]`.
1441    RustcNonConstTraitMethod,
1442
1443    /// Represents `#[rustc_nonnull_optimization_guaranteed]`.
1444    RustcNonnullOptimizationGuaranteed,
1445
1446    /// Represents `#[rustc_nounwind]`
1447    RustcNounwind,
1448
1449    /// Represents `#[rustc_objc_class]`
1450    RustcObjcClass {
1451        classname: Symbol,
1452    },
1453
1454    /// Represents `#[rustc_objc_selector]`
1455    RustcObjcSelector {
1456        methname: Symbol,
1457    },
1458
1459    /// Represents `#[rustc_offload_kernel]`
1460    RustcOffloadKernel,
1461
1462    /// Represents `#[rustc_panics_when_zero]` (used for linting).
1463    RustcPanicsWhenZero,
1464
1465    /// Represents `#[rustc_paren_sugar]`.
1466    RustcParenSugar,
1467
1468    /// Represents `#[rustc_pass_by_value]` (used by the `rustc_pass_by_value` lint).
1469    RustcPassByValue,
1470
1471    /// Represents `#[rustc_pass_indirectly_in_non_rustic_abis]`,
1472    ///
1473    /// See `TyAndLayout::pass_indirectly_in_non_rustic_abis` for details.
1474    RustcPassIndirectlyInNonRusticAbis(Span),
1475
1476    /// Represents `#[rustc_preserve_ub_checks]`
1477    RustcPreserveUbChecks,
1478
1479    /// Represents `#[rustc_proc_macro_decls]`
1480    RustcProcMacroDecls,
1481
1482    /// Represents `#[rustc_pub_transparent]` (used to mark a type as "publicly" transparent, for
1483    /// semver and documentation purposes).
1484    RustcPubTransparent(Span),
1485
1486    /// Represents `#[rustc_reallocator]`
1487    RustcReallocator,
1488
1489    /// Represents `#[rustc_regions]`
1490    RustcRegions,
1491
1492    /// Represents `#[rustc_scalable_vector(N)]`
1493    RustcScalableVector {
1494        /// The base multiple of lanes that are in a scalable vector, if provided. `element_count`
1495        /// is not provided for representing tuple types.
1496        element_count: Option<u16>,
1497    },
1498
1499    /// Represents `#[rustc_show_spans]`
1500    RustcShowSpans(ThinVec<RustcShowSpansKind>),
1501
1502    /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
1503    RustcSimdMonomorphizeLaneLimit(Limit),
1504
1505    /// Represents `#[rustc_skip_during_method_dispatch]`.
1506    RustcSkipDuringMethodDispatch {
1507        array: bool,
1508        boxed_slice: bool,
1509    },
1510
1511    /// Represents `#[rustc_specialization_trait]`.
1512    RustcSpecializationTrait,
1513
1514    /// Represents `#[rustc_std_internal_symbol]`.
1515    RustcStdInternalSymbol,
1516
1517    /// Represents `#[rustc_strict_coherence]`.
1518    RustcStrictCoherence(Span),
1519
1520    /// Represents the trace attribute of the `test` macro.
1521    RustcTestEntrypointMarker,
1522
1523    /// Represents `#[rustc_test_marker]`
1524    RustcTestMarker(Symbol),
1525
1526    /// Represents `#[rustc_then_this_would_need]`
1527    RustcThenThisWouldNeed(ThinVec<Ident>),
1528
1529    /// Represents `#[rustc_trivial_field_reads]`
1530    RustcTrivialFieldReads(Span),
1531
1532    /// Represents `#[sanitize]`
1533    ///
1534    /// the on set and off set are distjoint since there's a third option: unset.
1535    /// a node may not set the sanitizer setting in which case it inherits from parents.
1536    /// rtsan is unset if None
1537    Sanitize {
1538        on_set: SanitizerSet,
1539        off_set: SanitizerSet,
1540        rtsan: Option<RtsanSetting>,
1541        span: Span,
1542    },
1543
1544    /// Represents `#[should_panic]`
1545    ShouldPanic {
1546        reason: Option<Symbol>,
1547    },
1548
1549    /// Represents `#[rustc_splat]`.
1550    ///
1551    /// The `#[rustc_splat]` attribute is part of the `splat` experiment that improves the
1552    /// ergonomics of function overloading, tracked in
1553    /// <https://github.com/rust-lang/rust/issues/153629>.
1554    Splat(Span),
1555
1556    /// Represents `#[stable]`, `#[unstable]` and `#[rustc_allowed_through_unstable_modules]`.
1557    Stability {
1558        stability: Stability,
1559        /// Span of the attribute.
1560        span: Span,
1561    },
1562
1563    /// Represents `#[target_feature(enable = "...")]` and
1564    /// `#[unsafe(force_target_feature(enable = "...")]`.
1565    TargetFeature {
1566        features: ThinVec<(Symbol, Span)>,
1567        attr_span: Span,
1568        was_forced: bool,
1569    },
1570
1571    /// Represents `#![test_runner(path)]`
1572    TestRunner(Path),
1573
1574    /// Represents `#[thread_local]`
1575    ThreadLocal,
1576
1577    /// Represents `#[track_caller]`
1578    TrackCaller(Span),
1579
1580    /// Represents `#[type_length_limit]`
1581    TypeLengthLimit {
1582        limit: Limit,
1583    },
1584
1585    /// Represents `#[rustc_unchecked_type_alias]`
1586    // FIXME(#134963): Temporarily prefixed with `rustc_` to prevent potential name resolution ambiguities.
1587    UncheckedTypeAlias,
1588
1589    /// Represents `#[rustc_unroll]`.
1590    ///
1591    /// Tracked in <https://github.com/rust-lang/rust/issues/156874>.
1592    ///
1593    /// FIXME(#159429): temporarily renamed from `#[unroll]` to mitigate nameres ambiguity.
1594    Unroll(UnrollAttr),
1595
1596    /// Represents `#[unstable_feature_bound]`.
1597    UnstableFeatureBound(ThinVec<(Symbol, Span)>),
1598
1599    /// Represents all `#![unstable_removed(...)]` features
1600    UnstableRemoved(ThinVec<UnstableRemovedFeature>),
1601
1602    /// Represents `#[used]`
1603    Used {
1604        used_by: UsedBy,
1605    },
1606
1607    /// Represents `#[windows_subsystem]`.
1608    WindowsSubsystem(WindowsSubsystemKind),
1609    // tidy-alphabetical-end
1610}