Skip to main content

rustc_hir/
lang_items.rs

1//! Defines lang items.
2//!
3//! Language items are items that represent concepts intrinsic to the language
4//! itself. Examples are:
5//!
6//! * Traits that specify "kinds"; e.g., `Sync`, `Send`.
7//! * Traits that represent operators; e.g., `Add`, `Sub`, `Index`.
8//! * Functions called by the compiler itself.
9
10use rustc_ast::attr::AttributeExt;
11use rustc_data_structures::fx::FxIndexMap;
12use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
13use rustc_macros::{BlobDecodable, Encodable, HashStable_Generic};
14use rustc_span::{Span, Symbol, kw, sym};
15
16use crate::def_id::DefId;
17use crate::{MethodKind, Target};
18
19/// All of the lang items, defined or not.
20/// Defined lang items can come from the current crate or its dependencies.
21#[derive(const _: () =
    {
        impl<__CTX> ::rustc_data_structures::stable_hasher::HashStable<__CTX>
            for LanguageItems where __CTX: crate::HashStableContext {
            #[inline]
            fn hash_stable(&self, __hcx: &mut __CTX,
                __hasher:
                    &mut ::rustc_data_structures::stable_hasher::StableHasher) {
                match *self {
                    LanguageItems {
                        items: ref __binding_0,
                        reverse_items: ref __binding_1,
                        missing: ref __binding_2 } => {
                        { __binding_0.hash_stable(__hcx, __hasher); }
                        { __binding_1.hash_stable(__hcx, __hasher); }
                        { __binding_2.hash_stable(__hcx, __hasher); }
                    }
                }
            }
        }
    };HashStable_Generic, #[automatically_derived]
impl ::core::fmt::Debug for LanguageItems {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field3_finish(f, "LanguageItems",
            "items", &self.items, "reverse_items", &self.reverse_items,
            "missing", &&self.missing)
    }
}Debug)]
22pub struct LanguageItems {
23    /// Mappings from lang items to their possibly found [`DefId`]s.
24    /// The index corresponds to the order in [`LangItem`].
25    items: [Option<DefId>; std::mem::variant_count::<LangItem>()],
26    reverse_items: FxIndexMap<DefId, LangItem>,
27    /// Lang items that were not found during collection.
28    pub missing: Vec<LangItem>,
29}
30
31impl LanguageItems {
32    /// Construct an empty collection of lang items and no missing ones.
33    pub fn new() -> Self {
34        Self {
35            items: [None; std::mem::variant_count::<LangItem>()],
36            reverse_items: FxIndexMap::default(),
37            missing: Vec::new(),
38        }
39    }
40
41    pub fn get(&self, item: LangItem) -> Option<DefId> {
42        self.items[item as usize]
43    }
44
45    pub fn set(&mut self, item: LangItem, def_id: DefId) {
46        self.items[item as usize] = Some(def_id);
47        let preexisting = self.reverse_items.insert(def_id, item);
48
49        // This needs to be a bijection.
50        if let Some(preexisting) = preexisting {
51            {
    ::core::panicking::panic_fmt(format_args!("For the bijection of LangItem <=> DefId to work,one item DefId may only be assigned one LangItem. Separate the LangItem definitions for {0:?} and {1:?}.",
            item, preexisting));
};panic!(
52                "For the bijection of LangItem <=> DefId to work,\
53                one item DefId may only be assigned one LangItem. \
54                Separate the LangItem definitions for {item:?} and {preexisting:?}."
55            );
56        }
57    }
58
59    pub fn from_def_id(&self, def_id: DefId) -> Option<LangItem> {
60        self.reverse_items.get(&def_id).copied()
61    }
62
63    pub fn iter(&self) -> impl Iterator<Item = (LangItem, DefId)> {
64        self.items
65            .iter()
66            .enumerate()
67            .filter_map(|(i, id)| id.map(|id| (LangItem::from_u32(i as u32).unwrap(), id)))
68    }
69}
70
71// The actual lang items defined come at the end of this file in one handy table.
72// So you probably just want to nip down to the end.
73macro_rules! language_item_table {
74    (
75        $( $(#[$attr:meta])* $variant:ident, $module:ident :: $name:ident, $method:ident, $target:expr, $generics:expr; )*
76    ) => {
77        /// A representation of all the valid lang items in Rust.
78        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, BlobDecodable)]
79        pub enum LangItem {
80            $(
81                #[doc = concat!("The `", stringify!($name), "` lang item.")]
82                $(#[$attr])*
83                $variant,
84            )*
85        }
86
87        impl LangItem {
88            fn from_u32(u: u32) -> Option<LangItem> {
89                // This implementation is clumsy, but makes no assumptions
90                // about how discriminant tags are allocated within the
91                // range `0 .. std::mem::variant_count::<LangItem>()`.
92                $(if u == LangItem::$variant as u32 {
93                    return Some(LangItem::$variant)
94                })*
95                None
96            }
97
98            /// Returns the `name` symbol in `#[lang = "$name"]`.
99            /// For example, [`LangItem::PartialEq`]`.name()`
100            /// would result in [`sym::eq`] since it is `#[lang = "eq"]`.
101            pub fn name(self) -> Symbol {
102                match self {
103                    $( LangItem::$variant => $module::$name, )*
104                }
105            }
106
107            /// Opposite of [`LangItem::name`]
108            pub fn from_name(name: Symbol) -> Option<Self> {
109                match name {
110                    $( $module::$name => Some(LangItem::$variant), )*
111                    _ => None,
112                }
113            }
114
115            /// Returns the name of the `LangItem` enum variant.
116            // This method is used by Clippy for internal lints.
117            pub fn variant_name(self) -> &'static str {
118                match self {
119                    $( LangItem::$variant => stringify!($variant), )*
120                }
121            }
122
123            pub fn target(self) -> Target {
124                match self {
125                    $( LangItem::$variant => $target, )*
126                }
127            }
128
129            pub fn required_generics(&self) -> GenericRequirement {
130                match self {
131                    $( LangItem::$variant => $generics, )*
132                }
133            }
134        }
135
136        impl LanguageItems {
137            $(
138                #[doc = concat!("Returns the [`DefId`] of the `", stringify!($name), "` lang item if it is defined.")]
139                pub fn $method(&self) -> Option<DefId> {
140                    self.items[LangItem::$variant as usize]
141                }
142            )*
143        }
144    }
145}
146
147impl<CTX> HashStable<CTX> for LangItem {
148    fn hash_stable(&self, _: &mut CTX, hasher: &mut StableHasher) {
149        ::std::hash::Hash::hash(self, hasher);
150    }
151}
152
153/// Extracts the first `lang = "$name"` out of a list of attributes.
154/// The `#[panic_handler]` attribute is also extracted out when found.
155pub fn extract(attrs: &[impl AttributeExt]) -> Option<(Symbol, Span)> {
156    attrs.iter().find_map(|attr| {
157        Some(match attr {
158            _ if attr.has_name(sym::lang) => (attr.value_str()?, attr.span()),
159            _ if attr.has_name(sym::panic_handler) => (sym::panic_impl, attr.span()),
160            _ => return None,
161        })
162    })
163}
164
165/// A representation of all the valid lang items in Rust.
pub enum LangItem {

    #[doc = "The `sized` lang item."]
    Sized,

    #[doc = "The `meta_sized` lang item."]
    MetaSized,

    #[doc = "The `pointee_sized` lang item."]
    PointeeSized,

    #[doc = "The `unsize` lang item."]
    Unsize,

    #[doc = "The `mem_align_const` lang item."]
    AlignOf,

    #[doc = "The `mem_size_const` lang item."]
    SizeOf,

    #[doc = "The `offset_of` lang item."]
    OffsetOf,

    #[doc = "The `structural_peq` lang item."]
    #[doc =
    r#" Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ")."#]
    StructuralPeq,

    #[doc = "The `copy` lang item."]
    Copy,

    #[doc = "The `clone` lang item."]
    Clone,

    #[doc = "The `clone_fn` lang item."]
    CloneFn,

    #[doc = "The `use_cloned` lang item."]
    UseCloned,

    #[doc = "The `trivial_clone` lang item."]
    TrivialClone,

    #[doc = "The `sync` lang item."]
    Sync,

    #[doc = "The `discriminant_kind` lang item."]
    DiscriminantKind,

    #[doc = "The `discriminant_type` lang item."]
    #[doc = r" The associated item of the `DiscriminantKind` trait."]
    Discriminant,

    #[doc = "The `pointee_trait` lang item."]
    PointeeTrait,

    #[doc = "The `metadata_type` lang item."]
    Metadata,

    #[doc = "The `dyn_metadata` lang item."]
    DynMetadata,

    #[doc = "The `freeze` lang item."]
    Freeze,

    #[doc = "The `unsafe_unpin` lang item."]
    UnsafeUnpin,

    #[doc = "The `fn_ptr_trait` lang item."]
    FnPtrTrait,

    #[doc = "The `fn_ptr_addr` lang item."]
    FnPtrAddr,

    #[doc = "The `drop` lang item."]
    Drop,

    #[doc = "The `destruct` lang item."]
    Destruct,

    #[doc = "The `async_drop` lang item."]
    AsyncDrop,

    #[doc = "The `async_drop_in_place` lang item."]
    AsyncDropInPlace,

    #[doc = "The `coerce_unsized` lang item."]
    CoerceUnsized,

    #[doc = "The `dispatch_from_dyn` lang item."]
    DispatchFromDyn,

    #[doc = "The `transmute_opts` lang item."]
    TransmuteOpts,

    #[doc = "The `transmute_trait` lang item."]
    TransmuteTrait,

    #[doc = "The `add` lang item."]
    Add,

    #[doc = "The `sub` lang item."]
    Sub,

    #[doc = "The `mul` lang item."]
    Mul,

    #[doc = "The `div` lang item."]
    Div,

    #[doc = "The `rem` lang item."]
    Rem,

    #[doc = "The `neg` lang item."]
    Neg,

    #[doc = "The `not` lang item."]
    Not,

    #[doc = "The `bitxor` lang item."]
    BitXor,

    #[doc = "The `bitand` lang item."]
    BitAnd,

    #[doc = "The `bitor` lang item."]
    BitOr,

    #[doc = "The `shl` lang item."]
    Shl,

    #[doc = "The `shr` lang item."]
    Shr,

    #[doc = "The `add_assign` lang item."]
    AddAssign,

    #[doc = "The `sub_assign` lang item."]
    SubAssign,

    #[doc = "The `mul_assign` lang item."]
    MulAssign,

    #[doc = "The `div_assign` lang item."]
    DivAssign,

    #[doc = "The `rem_assign` lang item."]
    RemAssign,

    #[doc = "The `bitxor_assign` lang item."]
    BitXorAssign,

    #[doc = "The `bitand_assign` lang item."]
    BitAndAssign,

    #[doc = "The `bitor_assign` lang item."]
    BitOrAssign,

    #[doc = "The `shl_assign` lang item."]
    ShlAssign,

    #[doc = "The `shr_assign` lang item."]
    ShrAssign,

    #[doc = "The `index` lang item."]
    Index,

    #[doc = "The `index_mut` lang item."]
    IndexMut,

    #[doc = "The `unsafe_cell` lang item."]
    UnsafeCell,

    #[doc = "The `unsafe_pinned` lang item."]
    UnsafePinned,

    #[doc = "The `va_list` lang item."]
    VaList,

    #[doc = "The `deref` lang item."]
    Deref,

    #[doc = "The `deref_mut` lang item."]
    DerefMut,

    #[doc = "The `deref_pure` lang item."]
    DerefPure,

    #[doc = "The `deref_target` lang item."]
    DerefTarget,

    #[doc = "The `receiver` lang item."]
    Receiver,

    #[doc = "The `receiver_target` lang item."]
    ReceiverTarget,

    #[doc = "The `legacy_receiver` lang item."]
    LegacyReceiver,

    #[doc = "The `Fn` lang item."]
    Fn,

    #[doc = "The `fn_mut` lang item."]
    FnMut,

    #[doc = "The `fn_once` lang item."]
    FnOnce,

    #[doc = "The `async_fn` lang item."]
    AsyncFn,

    #[doc = "The `async_fn_mut` lang item."]
    AsyncFnMut,

    #[doc = "The `async_fn_once` lang item."]
    AsyncFnOnce,

    #[doc = "The `async_fn_once_output` lang item."]
    AsyncFnOnceOutput,

    #[doc = "The `call_once_future` lang item."]
    CallOnceFuture,

    #[doc = "The `call_ref_future` lang item."]
    CallRefFuture,

    #[doc = "The `async_fn_kind_helper` lang item."]
    AsyncFnKindHelper,

    #[doc = "The `async_fn_kind_upvars` lang item."]
    AsyncFnKindUpvars,

    #[doc = "The `fn_once_output` lang item."]
    FnOnceOutput,

    #[doc = "The `iterator` lang item."]
    Iterator,

    #[doc = "The `fused_iterator` lang item."]
    FusedIterator,

    #[doc = "The `future_trait` lang item."]
    Future,

    #[doc = "The `future_output` lang item."]
    FutureOutput,

    #[doc = "The `async_iterator` lang item."]
    AsyncIterator,

    #[doc = "The `coroutine_state` lang item."]
    CoroutineState,

    #[doc = "The `coroutine` lang item."]
    Coroutine,

    #[doc = "The `coroutine_return` lang item."]
    CoroutineReturn,

    #[doc = "The `coroutine_yield` lang item."]
    CoroutineYield,

    #[doc = "The `coroutine_resume` lang item."]
    CoroutineResume,

    #[doc = "The `unpin` lang item."]
    Unpin,

    #[doc = "The `pin` lang item."]
    Pin,

    #[doc = "The `Ordering` lang item."]
    OrderingEnum,

    #[doc = "The `eq` lang item."]
    PartialEq,

    #[doc = "The `partial_ord` lang item."]
    PartialOrd,

    #[doc = "The `c_void` lang item."]
    CVoid,

    #[doc = "The `type_info` lang item."]
    Type,

    #[doc = "The `type_id` lang item."]
    TypeId,

    #[doc = "The `panic` lang item."]
    Panic,

    #[doc = "The `panic_nounwind` lang item."]
    PanicNounwind,

    #[doc = "The `panic_fmt` lang item."]
    PanicFmt,

    #[doc = "The `panic_display` lang item."]
    PanicDisplay,

    #[doc = "The `const_panic_fmt` lang item."]
    ConstPanicFmt,

    #[doc = "The `panic_bounds_check` lang item."]
    PanicBoundsCheck,

    #[doc = "The `panic_misaligned_pointer_dereference` lang item."]
    PanicMisalignedPointerDereference,

    #[doc = "The `panic_info` lang item."]
    PanicInfo,

    #[doc = "The `panic_location` lang item."]
    PanicLocation,

    #[doc = "The `panic_impl` lang item."]
    PanicImpl,

    #[doc = "The `panic_cannot_unwind` lang item."]
    PanicCannotUnwind,

    #[doc = "The `panic_in_cleanup` lang item."]
    PanicInCleanup,

    #[doc = "The `panic_const_add_overflow` lang item."]
    #[doc = r" Constant panic messages, used for codegen of MIR asserts."]
    PanicAddOverflow,

    #[doc = "The `panic_const_sub_overflow` lang item."]
    PanicSubOverflow,

    #[doc = "The `panic_const_mul_overflow` lang item."]
    PanicMulOverflow,

    #[doc = "The `panic_const_div_overflow` lang item."]
    PanicDivOverflow,

    #[doc = "The `panic_const_rem_overflow` lang item."]
    PanicRemOverflow,

    #[doc = "The `panic_const_neg_overflow` lang item."]
    PanicNegOverflow,

    #[doc = "The `panic_const_shr_overflow` lang item."]
    PanicShrOverflow,

    #[doc = "The `panic_const_shl_overflow` lang item."]
    PanicShlOverflow,

    #[doc = "The `panic_const_div_by_zero` lang item."]
    PanicDivZero,

    #[doc = "The `panic_const_rem_by_zero` lang item."]
    PanicRemZero,

    #[doc = "The `panic_const_coroutine_resumed` lang item."]
    PanicCoroutineResumed,

    #[doc = "The `panic_const_async_fn_resumed` lang item."]
    PanicAsyncFnResumed,

    #[doc = "The `panic_const_async_gen_fn_resumed` lang item."]
    PanicAsyncGenFnResumed,

    #[doc = "The `panic_const_gen_fn_none` lang item."]
    PanicGenFnNone,

    #[doc = "The `panic_const_coroutine_resumed_panic` lang item."]
    PanicCoroutineResumedPanic,

    #[doc = "The `panic_const_async_fn_resumed_panic` lang item."]
    PanicAsyncFnResumedPanic,

    #[doc = "The `panic_const_async_gen_fn_resumed_panic` lang item."]
    PanicAsyncGenFnResumedPanic,

    #[doc = "The `panic_const_gen_fn_none_panic` lang item."]
    PanicGenFnNonePanic,

    #[doc = "The `panic_null_pointer_dereference` lang item."]
    PanicNullPointerDereference,

    #[doc = "The `panic_invalid_enum_construction` lang item."]
    PanicInvalidEnumConstruction,

    #[doc = "The `panic_const_coroutine_resumed_drop` lang item."]
    PanicCoroutineResumedDrop,

    #[doc = "The `panic_const_async_fn_resumed_drop` lang item."]
    PanicAsyncFnResumedDrop,

    #[doc = "The `panic_const_async_gen_fn_resumed_drop` lang item."]
    PanicAsyncGenFnResumedDrop,

    #[doc = "The `panic_const_gen_fn_none_drop` lang item."]
    PanicGenFnNoneDrop,

    #[doc = "The `begin_panic` lang item."]
    #[doc =
    r" libstd panic entry point. Necessary for const eval to be able to catch it"]
    BeginPanic,

    #[doc = "The `format_argument` lang item."]
    FormatArgument,

    #[doc = "The `format_arguments` lang item."]
    FormatArguments,

    #[doc = "The `exchange_malloc` lang item."]
    ExchangeMalloc,

    #[doc = "The `drop_in_place` lang item."]
    DropInPlace,

    #[doc = "The `alloc_layout` lang item."]
    AllocLayout,

    #[doc = "The `start` lang item."]
    #[doc =
    r#" For all binary crates without `#![no_main]`, Rust will generate a "main" function."#]
    #[doc =
    r#" The exact name and signature are target-dependent. The "main" function will invoke"#]
    #[doc =
    r" this lang item, passing it the `argc` and `argv` (or null, if those don't exist"]
    #[doc =
    r" on the current target) as well as the user-defined `fn main` from the binary crate."]
    Start,

    #[doc = "The `eh_personality` lang item."]
    EhPersonality,

    #[doc = "The `eh_catch_typeinfo` lang item."]
    EhCatchTypeinfo,

    #[doc = "The `compiler_move` lang item."]
    CompilerMove,

    #[doc = "The `compiler_copy` lang item."]
    CompilerCopy,

    #[doc = "The `owned_box` lang item."]
    OwnedBox,

    #[doc = "The `global_alloc_ty` lang item."]
    GlobalAlloc,

    #[doc = "The `phantom_data` lang item."]
    PhantomData,

    #[doc = "The `manually_drop` lang item."]
    ManuallyDrop,

    #[doc = "The `bikeshed_guaranteed_no_drop` lang item."]
    BikeshedGuaranteedNoDrop,

    #[doc = "The `maybe_uninit` lang item."]
    MaybeUninit,

    #[doc = "The `termination` lang item."]
    Termination,

    #[doc = "The `Try` lang item."]
    Try,

    #[doc = "The `tuple_trait` lang item."]
    Tuple,

    #[doc = "The `slice_len_fn` lang item."]
    SliceLen,

    #[doc = "The `from_residual` lang item."]
    TryTraitFromResidual,

    #[doc = "The `from_output` lang item."]
    TryTraitFromOutput,

    #[doc = "The `branch` lang item."]
    TryTraitBranch,

    #[doc = "The `from_yeet` lang item."]
    TryTraitFromYeet,

    #[doc = "The `into_try_type` lang item."]
    ResidualIntoTryType,

    #[doc = "The `coerce_pointee_validated` lang item."]
    CoercePointeeValidated,

    #[doc = "The `const_param_ty` lang item."]
    ConstParamTy,

    #[doc = "The `Poll` lang item."]
    Poll,

    #[doc = "The `Ready` lang item."]
    PollReady,

    #[doc = "The `Pending` lang item."]
    PollPending,

    #[doc = "The `AsyncGenReady` lang item."]
    AsyncGenReady,

    #[doc = "The `AsyncGenPending` lang item."]
    AsyncGenPending,

    #[doc = "The `AsyncGenFinished` lang item."]
    AsyncGenFinished,

    #[doc = "The `ResumeTy` lang item."]
    ResumeTy,

    #[doc = "The `get_context` lang item."]
    GetContext,

    #[doc = "The `Context` lang item."]
    Context,

    #[doc = "The `poll` lang item."]
    FuturePoll,

    #[doc = "The `async_iterator_poll_next` lang item."]
    AsyncIteratorPollNext,

    #[doc = "The `into_async_iter_into_iter` lang item."]
    IntoAsyncIterIntoIter,

    #[doc = "The `Option` lang item."]
    Option,

    #[doc = "The `Some` lang item."]
    OptionSome,

    #[doc = "The `None` lang item."]
    OptionNone,

    #[doc = "The `Ok` lang item."]
    ResultOk,

    #[doc = "The `Err` lang item."]
    ResultErr,

    #[doc = "The `Continue` lang item."]
    ControlFlowContinue,

    #[doc = "The `Break` lang item."]
    ControlFlowBreak,

    #[doc = "The `into_future` lang item."]
    IntoFutureIntoFuture,

    #[doc = "The `into_iter` lang item."]
    IntoIterIntoIter,

    #[doc = "The `next` lang item."]
    IteratorNext,

    #[doc = "The `new_unchecked` lang item."]
    PinNewUnchecked,

    #[doc = "The `RangeFrom` lang item."]
    RangeFrom,

    #[doc = "The `RangeFull` lang item."]
    RangeFull,

    #[doc = "The `RangeInclusive` lang item."]
    RangeInclusiveStruct,

    #[doc = "The `range_inclusive_new` lang item."]
    RangeInclusiveNew,

    #[doc = "The `Range` lang item."]
    Range,

    #[doc = "The `RangeToInclusive` lang item."]
    RangeToInclusive,

    #[doc = "The `RangeTo` lang item."]
    RangeTo,

    #[doc = "The `RangeMax` lang item."]
    RangeMax,

    #[doc = "The `RangeMin` lang item."]
    RangeMin,

    #[doc = "The `RangeSub` lang item."]
    RangeSub,

    #[doc = "The `RangeFromCopy` lang item."]
    RangeFromCopy,

    #[doc = "The `RangeCopy` lang item."]
    RangeCopy,

    #[doc = "The `RangeInclusiveCopy` lang item."]
    RangeInclusiveCopy,

    #[doc = "The `RangeToInclusiveCopy` lang item."]
    RangeToInclusiveCopy,

    #[doc = "The `String` lang item."]
    String,

    #[doc = "The `CStr` lang item."]
    CStr,

    #[doc = "The `contract_build_check_ensures` lang item."]
    ContractBuildCheckEnsures,

    #[doc = "The `contract_check_requires` lang item."]
    ContractCheckRequires,

    #[doc = "The `default_trait4` lang item."]
    DefaultTrait4,

    #[doc = "The `default_trait3` lang item."]
    DefaultTrait3,

    #[doc = "The `default_trait2` lang item."]
    DefaultTrait2,

    #[doc = "The `default_trait1` lang item."]
    DefaultTrait1,

    #[doc = "The `contract_check_ensures` lang item."]
    ContractCheckEnsures,

    #[doc = "The `reborrow` lang item."]
    Reborrow,

    #[doc = "The `coerce_shared` lang item."]
    CoerceShared,
}
#[automatically_derived]
impl ::core::fmt::Debug for LangItem {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                LangItem::Sized => "Sized",
                LangItem::MetaSized => "MetaSized",
                LangItem::PointeeSized => "PointeeSized",
                LangItem::Unsize => "Unsize",
                LangItem::AlignOf => "AlignOf",
                LangItem::SizeOf => "SizeOf",
                LangItem::OffsetOf => "OffsetOf",
                LangItem::StructuralPeq => "StructuralPeq",
                LangItem::Copy => "Copy",
                LangItem::Clone => "Clone",
                LangItem::CloneFn => "CloneFn",
                LangItem::UseCloned => "UseCloned",
                LangItem::TrivialClone => "TrivialClone",
                LangItem::Sync => "Sync",
                LangItem::DiscriminantKind => "DiscriminantKind",
                LangItem::Discriminant => "Discriminant",
                LangItem::PointeeTrait => "PointeeTrait",
                LangItem::Metadata => "Metadata",
                LangItem::DynMetadata => "DynMetadata",
                LangItem::Freeze => "Freeze",
                LangItem::UnsafeUnpin => "UnsafeUnpin",
                LangItem::FnPtrTrait => "FnPtrTrait",
                LangItem::FnPtrAddr => "FnPtrAddr",
                LangItem::Drop => "Drop",
                LangItem::Destruct => "Destruct",
                LangItem::AsyncDrop => "AsyncDrop",
                LangItem::AsyncDropInPlace => "AsyncDropInPlace",
                LangItem::CoerceUnsized => "CoerceUnsized",
                LangItem::DispatchFromDyn => "DispatchFromDyn",
                LangItem::TransmuteOpts => "TransmuteOpts",
                LangItem::TransmuteTrait => "TransmuteTrait",
                LangItem::Add => "Add",
                LangItem::Sub => "Sub",
                LangItem::Mul => "Mul",
                LangItem::Div => "Div",
                LangItem::Rem => "Rem",
                LangItem::Neg => "Neg",
                LangItem::Not => "Not",
                LangItem::BitXor => "BitXor",
                LangItem::BitAnd => "BitAnd",
                LangItem::BitOr => "BitOr",
                LangItem::Shl => "Shl",
                LangItem::Shr => "Shr",
                LangItem::AddAssign => "AddAssign",
                LangItem::SubAssign => "SubAssign",
                LangItem::MulAssign => "MulAssign",
                LangItem::DivAssign => "DivAssign",
                LangItem::RemAssign => "RemAssign",
                LangItem::BitXorAssign => "BitXorAssign",
                LangItem::BitAndAssign => "BitAndAssign",
                LangItem::BitOrAssign => "BitOrAssign",
                LangItem::ShlAssign => "ShlAssign",
                LangItem::ShrAssign => "ShrAssign",
                LangItem::Index => "Index",
                LangItem::IndexMut => "IndexMut",
                LangItem::UnsafeCell => "UnsafeCell",
                LangItem::UnsafePinned => "UnsafePinned",
                LangItem::VaList => "VaList",
                LangItem::Deref => "Deref",
                LangItem::DerefMut => "DerefMut",
                LangItem::DerefPure => "DerefPure",
                LangItem::DerefTarget => "DerefTarget",
                LangItem::Receiver => "Receiver",
                LangItem::ReceiverTarget => "ReceiverTarget",
                LangItem::LegacyReceiver => "LegacyReceiver",
                LangItem::Fn => "Fn",
                LangItem::FnMut => "FnMut",
                LangItem::FnOnce => "FnOnce",
                LangItem::AsyncFn => "AsyncFn",
                LangItem::AsyncFnMut => "AsyncFnMut",
                LangItem::AsyncFnOnce => "AsyncFnOnce",
                LangItem::AsyncFnOnceOutput => "AsyncFnOnceOutput",
                LangItem::CallOnceFuture => "CallOnceFuture",
                LangItem::CallRefFuture => "CallRefFuture",
                LangItem::AsyncFnKindHelper => "AsyncFnKindHelper",
                LangItem::AsyncFnKindUpvars => "AsyncFnKindUpvars",
                LangItem::FnOnceOutput => "FnOnceOutput",
                LangItem::Iterator => "Iterator",
                LangItem::FusedIterator => "FusedIterator",
                LangItem::Future => "Future",
                LangItem::FutureOutput => "FutureOutput",
                LangItem::AsyncIterator => "AsyncIterator",
                LangItem::CoroutineState => "CoroutineState",
                LangItem::Coroutine => "Coroutine",
                LangItem::CoroutineReturn => "CoroutineReturn",
                LangItem::CoroutineYield => "CoroutineYield",
                LangItem::CoroutineResume => "CoroutineResume",
                LangItem::Unpin => "Unpin",
                LangItem::Pin => "Pin",
                LangItem::OrderingEnum => "OrderingEnum",
                LangItem::PartialEq => "PartialEq",
                LangItem::PartialOrd => "PartialOrd",
                LangItem::CVoid => "CVoid",
                LangItem::Type => "Type",
                LangItem::TypeId => "TypeId",
                LangItem::Panic => "Panic",
                LangItem::PanicNounwind => "PanicNounwind",
                LangItem::PanicFmt => "PanicFmt",
                LangItem::PanicDisplay => "PanicDisplay",
                LangItem::ConstPanicFmt => "ConstPanicFmt",
                LangItem::PanicBoundsCheck => "PanicBoundsCheck",
                LangItem::PanicMisalignedPointerDereference =>
                    "PanicMisalignedPointerDereference",
                LangItem::PanicInfo => "PanicInfo",
                LangItem::PanicLocation => "PanicLocation",
                LangItem::PanicImpl => "PanicImpl",
                LangItem::PanicCannotUnwind => "PanicCannotUnwind",
                LangItem::PanicInCleanup => "PanicInCleanup",
                LangItem::PanicAddOverflow => "PanicAddOverflow",
                LangItem::PanicSubOverflow => "PanicSubOverflow",
                LangItem::PanicMulOverflow => "PanicMulOverflow",
                LangItem::PanicDivOverflow => "PanicDivOverflow",
                LangItem::PanicRemOverflow => "PanicRemOverflow",
                LangItem::PanicNegOverflow => "PanicNegOverflow",
                LangItem::PanicShrOverflow => "PanicShrOverflow",
                LangItem::PanicShlOverflow => "PanicShlOverflow",
                LangItem::PanicDivZero => "PanicDivZero",
                LangItem::PanicRemZero => "PanicRemZero",
                LangItem::PanicCoroutineResumed => "PanicCoroutineResumed",
                LangItem::PanicAsyncFnResumed => "PanicAsyncFnResumed",
                LangItem::PanicAsyncGenFnResumed => "PanicAsyncGenFnResumed",
                LangItem::PanicGenFnNone => "PanicGenFnNone",
                LangItem::PanicCoroutineResumedPanic =>
                    "PanicCoroutineResumedPanic",
                LangItem::PanicAsyncFnResumedPanic =>
                    "PanicAsyncFnResumedPanic",
                LangItem::PanicAsyncGenFnResumedPanic =>
                    "PanicAsyncGenFnResumedPanic",
                LangItem::PanicGenFnNonePanic => "PanicGenFnNonePanic",
                LangItem::PanicNullPointerDereference =>
                    "PanicNullPointerDereference",
                LangItem::PanicInvalidEnumConstruction =>
                    "PanicInvalidEnumConstruction",
                LangItem::PanicCoroutineResumedDrop =>
                    "PanicCoroutineResumedDrop",
                LangItem::PanicAsyncFnResumedDrop =>
                    "PanicAsyncFnResumedDrop",
                LangItem::PanicAsyncGenFnResumedDrop =>
                    "PanicAsyncGenFnResumedDrop",
                LangItem::PanicGenFnNoneDrop => "PanicGenFnNoneDrop",
                LangItem::BeginPanic => "BeginPanic",
                LangItem::FormatArgument => "FormatArgument",
                LangItem::FormatArguments => "FormatArguments",
                LangItem::ExchangeMalloc => "ExchangeMalloc",
                LangItem::DropInPlace => "DropInPlace",
                LangItem::AllocLayout => "AllocLayout",
                LangItem::Start => "Start",
                LangItem::EhPersonality => "EhPersonality",
                LangItem::EhCatchTypeinfo => "EhCatchTypeinfo",
                LangItem::CompilerMove => "CompilerMove",
                LangItem::CompilerCopy => "CompilerCopy",
                LangItem::OwnedBox => "OwnedBox",
                LangItem::GlobalAlloc => "GlobalAlloc",
                LangItem::PhantomData => "PhantomData",
                LangItem::ManuallyDrop => "ManuallyDrop",
                LangItem::BikeshedGuaranteedNoDrop =>
                    "BikeshedGuaranteedNoDrop",
                LangItem::MaybeUninit => "MaybeUninit",
                LangItem::Termination => "Termination",
                LangItem::Try => "Try",
                LangItem::Tuple => "Tuple",
                LangItem::SliceLen => "SliceLen",
                LangItem::TryTraitFromResidual => "TryTraitFromResidual",
                LangItem::TryTraitFromOutput => "TryTraitFromOutput",
                LangItem::TryTraitBranch => "TryTraitBranch",
                LangItem::TryTraitFromYeet => "TryTraitFromYeet",
                LangItem::ResidualIntoTryType => "ResidualIntoTryType",
                LangItem::CoercePointeeValidated => "CoercePointeeValidated",
                LangItem::ConstParamTy => "ConstParamTy",
                LangItem::Poll => "Poll",
                LangItem::PollReady => "PollReady",
                LangItem::PollPending => "PollPending",
                LangItem::AsyncGenReady => "AsyncGenReady",
                LangItem::AsyncGenPending => "AsyncGenPending",
                LangItem::AsyncGenFinished => "AsyncGenFinished",
                LangItem::ResumeTy => "ResumeTy",
                LangItem::GetContext => "GetContext",
                LangItem::Context => "Context",
                LangItem::FuturePoll => "FuturePoll",
                LangItem::AsyncIteratorPollNext => "AsyncIteratorPollNext",
                LangItem::IntoAsyncIterIntoIter => "IntoAsyncIterIntoIter",
                LangItem::Option => "Option",
                LangItem::OptionSome => "OptionSome",
                LangItem::OptionNone => "OptionNone",
                LangItem::ResultOk => "ResultOk",
                LangItem::ResultErr => "ResultErr",
                LangItem::ControlFlowContinue => "ControlFlowContinue",
                LangItem::ControlFlowBreak => "ControlFlowBreak",
                LangItem::IntoFutureIntoFuture => "IntoFutureIntoFuture",
                LangItem::IntoIterIntoIter => "IntoIterIntoIter",
                LangItem::IteratorNext => "IteratorNext",
                LangItem::PinNewUnchecked => "PinNewUnchecked",
                LangItem::RangeFrom => "RangeFrom",
                LangItem::RangeFull => "RangeFull",
                LangItem::RangeInclusiveStruct => "RangeInclusiveStruct",
                LangItem::RangeInclusiveNew => "RangeInclusiveNew",
                LangItem::Range => "Range",
                LangItem::RangeToInclusive => "RangeToInclusive",
                LangItem::RangeTo => "RangeTo",
                LangItem::RangeMax => "RangeMax",
                LangItem::RangeMin => "RangeMin",
                LangItem::RangeSub => "RangeSub",
                LangItem::RangeFromCopy => "RangeFromCopy",
                LangItem::RangeCopy => "RangeCopy",
                LangItem::RangeInclusiveCopy => "RangeInclusiveCopy",
                LangItem::RangeToInclusiveCopy => "RangeToInclusiveCopy",
                LangItem::String => "String",
                LangItem::CStr => "CStr",
                LangItem::ContractBuildCheckEnsures =>
                    "ContractBuildCheckEnsures",
                LangItem::ContractCheckRequires => "ContractCheckRequires",
                LangItem::DefaultTrait4 => "DefaultTrait4",
                LangItem::DefaultTrait3 => "DefaultTrait3",
                LangItem::DefaultTrait2 => "DefaultTrait2",
                LangItem::DefaultTrait1 => "DefaultTrait1",
                LangItem::ContractCheckEnsures => "ContractCheckEnsures",
                LangItem::Reborrow => "Reborrow",
                LangItem::CoerceShared => "CoerceShared",
            })
    }
}
#[automatically_derived]
impl ::core::marker::Copy for LangItem { }
#[automatically_derived]
#[doc(hidden)]
unsafe impl ::core::clone::TrivialClone for LangItem { }
#[automatically_derived]
impl ::core::clone::Clone for LangItem {
    #[inline]
    fn clone(&self) -> LangItem { *self }
}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for LangItem { }
#[automatically_derived]
impl ::core::cmp::PartialEq for LangItem {
    #[inline]
    fn eq(&self, other: &LangItem) -> bool {
        let __self_discr = ::core::intrinsics::discriminant_value(self);
        let __arg1_discr = ::core::intrinsics::discriminant_value(other);
        __self_discr == __arg1_discr
    }
}
#[automatically_derived]
impl ::core::cmp::Eq for LangItem {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) {}
}
#[automatically_derived]
impl ::core::hash::Hash for LangItem {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        let __self_discr = ::core::intrinsics::discriminant_value(self);
        ::core::hash::Hash::hash(&__self_discr, state)
    }
}
const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for LangItem {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        LangItem::Sized => { 0usize }
                        LangItem::MetaSized => { 1usize }
                        LangItem::PointeeSized => { 2usize }
                        LangItem::Unsize => { 3usize }
                        LangItem::AlignOf => { 4usize }
                        LangItem::SizeOf => { 5usize }
                        LangItem::OffsetOf => { 6usize }
                        LangItem::StructuralPeq => { 7usize }
                        LangItem::Copy => { 8usize }
                        LangItem::Clone => { 9usize }
                        LangItem::CloneFn => { 10usize }
                        LangItem::UseCloned => { 11usize }
                        LangItem::TrivialClone => { 12usize }
                        LangItem::Sync => { 13usize }
                        LangItem::DiscriminantKind => { 14usize }
                        LangItem::Discriminant => { 15usize }
                        LangItem::PointeeTrait => { 16usize }
                        LangItem::Metadata => { 17usize }
                        LangItem::DynMetadata => { 18usize }
                        LangItem::Freeze => { 19usize }
                        LangItem::UnsafeUnpin => { 20usize }
                        LangItem::FnPtrTrait => { 21usize }
                        LangItem::FnPtrAddr => { 22usize }
                        LangItem::Drop => { 23usize }
                        LangItem::Destruct => { 24usize }
                        LangItem::AsyncDrop => { 25usize }
                        LangItem::AsyncDropInPlace => { 26usize }
                        LangItem::CoerceUnsized => { 27usize }
                        LangItem::DispatchFromDyn => { 28usize }
                        LangItem::TransmuteOpts => { 29usize }
                        LangItem::TransmuteTrait => { 30usize }
                        LangItem::Add => { 31usize }
                        LangItem::Sub => { 32usize }
                        LangItem::Mul => { 33usize }
                        LangItem::Div => { 34usize }
                        LangItem::Rem => { 35usize }
                        LangItem::Neg => { 36usize }
                        LangItem::Not => { 37usize }
                        LangItem::BitXor => { 38usize }
                        LangItem::BitAnd => { 39usize }
                        LangItem::BitOr => { 40usize }
                        LangItem::Shl => { 41usize }
                        LangItem::Shr => { 42usize }
                        LangItem::AddAssign => { 43usize }
                        LangItem::SubAssign => { 44usize }
                        LangItem::MulAssign => { 45usize }
                        LangItem::DivAssign => { 46usize }
                        LangItem::RemAssign => { 47usize }
                        LangItem::BitXorAssign => { 48usize }
                        LangItem::BitAndAssign => { 49usize }
                        LangItem::BitOrAssign => { 50usize }
                        LangItem::ShlAssign => { 51usize }
                        LangItem::ShrAssign => { 52usize }
                        LangItem::Index => { 53usize }
                        LangItem::IndexMut => { 54usize }
                        LangItem::UnsafeCell => { 55usize }
                        LangItem::UnsafePinned => { 56usize }
                        LangItem::VaList => { 57usize }
                        LangItem::Deref => { 58usize }
                        LangItem::DerefMut => { 59usize }
                        LangItem::DerefPure => { 60usize }
                        LangItem::DerefTarget => { 61usize }
                        LangItem::Receiver => { 62usize }
                        LangItem::ReceiverTarget => { 63usize }
                        LangItem::LegacyReceiver => { 64usize }
                        LangItem::Fn => { 65usize }
                        LangItem::FnMut => { 66usize }
                        LangItem::FnOnce => { 67usize }
                        LangItem::AsyncFn => { 68usize }
                        LangItem::AsyncFnMut => { 69usize }
                        LangItem::AsyncFnOnce => { 70usize }
                        LangItem::AsyncFnOnceOutput => { 71usize }
                        LangItem::CallOnceFuture => { 72usize }
                        LangItem::CallRefFuture => { 73usize }
                        LangItem::AsyncFnKindHelper => { 74usize }
                        LangItem::AsyncFnKindUpvars => { 75usize }
                        LangItem::FnOnceOutput => { 76usize }
                        LangItem::Iterator => { 77usize }
                        LangItem::FusedIterator => { 78usize }
                        LangItem::Future => { 79usize }
                        LangItem::FutureOutput => { 80usize }
                        LangItem::AsyncIterator => { 81usize }
                        LangItem::CoroutineState => { 82usize }
                        LangItem::Coroutine => { 83usize }
                        LangItem::CoroutineReturn => { 84usize }
                        LangItem::CoroutineYield => { 85usize }
                        LangItem::CoroutineResume => { 86usize }
                        LangItem::Unpin => { 87usize }
                        LangItem::Pin => { 88usize }
                        LangItem::OrderingEnum => { 89usize }
                        LangItem::PartialEq => { 90usize }
                        LangItem::PartialOrd => { 91usize }
                        LangItem::CVoid => { 92usize }
                        LangItem::Type => { 93usize }
                        LangItem::TypeId => { 94usize }
                        LangItem::Panic => { 95usize }
                        LangItem::PanicNounwind => { 96usize }
                        LangItem::PanicFmt => { 97usize }
                        LangItem::PanicDisplay => { 98usize }
                        LangItem::ConstPanicFmt => { 99usize }
                        LangItem::PanicBoundsCheck => { 100usize }
                        LangItem::PanicMisalignedPointerDereference => { 101usize }
                        LangItem::PanicInfo => { 102usize }
                        LangItem::PanicLocation => { 103usize }
                        LangItem::PanicImpl => { 104usize }
                        LangItem::PanicCannotUnwind => { 105usize }
                        LangItem::PanicInCleanup => { 106usize }
                        LangItem::PanicAddOverflow => { 107usize }
                        LangItem::PanicSubOverflow => { 108usize }
                        LangItem::PanicMulOverflow => { 109usize }
                        LangItem::PanicDivOverflow => { 110usize }
                        LangItem::PanicRemOverflow => { 111usize }
                        LangItem::PanicNegOverflow => { 112usize }
                        LangItem::PanicShrOverflow => { 113usize }
                        LangItem::PanicShlOverflow => { 114usize }
                        LangItem::PanicDivZero => { 115usize }
                        LangItem::PanicRemZero => { 116usize }
                        LangItem::PanicCoroutineResumed => { 117usize }
                        LangItem::PanicAsyncFnResumed => { 118usize }
                        LangItem::PanicAsyncGenFnResumed => { 119usize }
                        LangItem::PanicGenFnNone => { 120usize }
                        LangItem::PanicCoroutineResumedPanic => { 121usize }
                        LangItem::PanicAsyncFnResumedPanic => { 122usize }
                        LangItem::PanicAsyncGenFnResumedPanic => { 123usize }
                        LangItem::PanicGenFnNonePanic => { 124usize }
                        LangItem::PanicNullPointerDereference => { 125usize }
                        LangItem::PanicInvalidEnumConstruction => { 126usize }
                        LangItem::PanicCoroutineResumedDrop => { 127usize }
                        LangItem::PanicAsyncFnResumedDrop => { 128usize }
                        LangItem::PanicAsyncGenFnResumedDrop => { 129usize }
                        LangItem::PanicGenFnNoneDrop => { 130usize }
                        LangItem::BeginPanic => { 131usize }
                        LangItem::FormatArgument => { 132usize }
                        LangItem::FormatArguments => { 133usize }
                        LangItem::ExchangeMalloc => { 134usize }
                        LangItem::DropInPlace => { 135usize }
                        LangItem::AllocLayout => { 136usize }
                        LangItem::Start => { 137usize }
                        LangItem::EhPersonality => { 138usize }
                        LangItem::EhCatchTypeinfo => { 139usize }
                        LangItem::CompilerMove => { 140usize }
                        LangItem::CompilerCopy => { 141usize }
                        LangItem::OwnedBox => { 142usize }
                        LangItem::GlobalAlloc => { 143usize }
                        LangItem::PhantomData => { 144usize }
                        LangItem::ManuallyDrop => { 145usize }
                        LangItem::BikeshedGuaranteedNoDrop => { 146usize }
                        LangItem::MaybeUninit => { 147usize }
                        LangItem::Termination => { 148usize }
                        LangItem::Try => { 149usize }
                        LangItem::Tuple => { 150usize }
                        LangItem::SliceLen => { 151usize }
                        LangItem::TryTraitFromResidual => { 152usize }
                        LangItem::TryTraitFromOutput => { 153usize }
                        LangItem::TryTraitBranch => { 154usize }
                        LangItem::TryTraitFromYeet => { 155usize }
                        LangItem::ResidualIntoTryType => { 156usize }
                        LangItem::CoercePointeeValidated => { 157usize }
                        LangItem::ConstParamTy => { 158usize }
                        LangItem::Poll => { 159usize }
                        LangItem::PollReady => { 160usize }
                        LangItem::PollPending => { 161usize }
                        LangItem::AsyncGenReady => { 162usize }
                        LangItem::AsyncGenPending => { 163usize }
                        LangItem::AsyncGenFinished => { 164usize }
                        LangItem::ResumeTy => { 165usize }
                        LangItem::GetContext => { 166usize }
                        LangItem::Context => { 167usize }
                        LangItem::FuturePoll => { 168usize }
                        LangItem::AsyncIteratorPollNext => { 169usize }
                        LangItem::IntoAsyncIterIntoIter => { 170usize }
                        LangItem::Option => { 171usize }
                        LangItem::OptionSome => { 172usize }
                        LangItem::OptionNone => { 173usize }
                        LangItem::ResultOk => { 174usize }
                        LangItem::ResultErr => { 175usize }
                        LangItem::ControlFlowContinue => { 176usize }
                        LangItem::ControlFlowBreak => { 177usize }
                        LangItem::IntoFutureIntoFuture => { 178usize }
                        LangItem::IntoIterIntoIter => { 179usize }
                        LangItem::IteratorNext => { 180usize }
                        LangItem::PinNewUnchecked => { 181usize }
                        LangItem::RangeFrom => { 182usize }
                        LangItem::RangeFull => { 183usize }
                        LangItem::RangeInclusiveStruct => { 184usize }
                        LangItem::RangeInclusiveNew => { 185usize }
                        LangItem::Range => { 186usize }
                        LangItem::RangeToInclusive => { 187usize }
                        LangItem::RangeTo => { 188usize }
                        LangItem::RangeMax => { 189usize }
                        LangItem::RangeMin => { 190usize }
                        LangItem::RangeSub => { 191usize }
                        LangItem::RangeFromCopy => { 192usize }
                        LangItem::RangeCopy => { 193usize }
                        LangItem::RangeInclusiveCopy => { 194usize }
                        LangItem::RangeToInclusiveCopy => { 195usize }
                        LangItem::String => { 196usize }
                        LangItem::CStr => { 197usize }
                        LangItem::ContractBuildCheckEnsures => { 198usize }
                        LangItem::ContractCheckRequires => { 199usize }
                        LangItem::DefaultTrait4 => { 200usize }
                        LangItem::DefaultTrait3 => { 201usize }
                        LangItem::DefaultTrait2 => { 202usize }
                        LangItem::DefaultTrait1 => { 203usize }
                        LangItem::ContractCheckEnsures => { 204usize }
                        LangItem::Reborrow => { 205usize }
                        LangItem::CoerceShared => { 206usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    LangItem::Sized => {}
                    LangItem::MetaSized => {}
                    LangItem::PointeeSized => {}
                    LangItem::Unsize => {}
                    LangItem::AlignOf => {}
                    LangItem::SizeOf => {}
                    LangItem::OffsetOf => {}
                    LangItem::StructuralPeq => {}
                    LangItem::Copy => {}
                    LangItem::Clone => {}
                    LangItem::CloneFn => {}
                    LangItem::UseCloned => {}
                    LangItem::TrivialClone => {}
                    LangItem::Sync => {}
                    LangItem::DiscriminantKind => {}
                    LangItem::Discriminant => {}
                    LangItem::PointeeTrait => {}
                    LangItem::Metadata => {}
                    LangItem::DynMetadata => {}
                    LangItem::Freeze => {}
                    LangItem::UnsafeUnpin => {}
                    LangItem::FnPtrTrait => {}
                    LangItem::FnPtrAddr => {}
                    LangItem::Drop => {}
                    LangItem::Destruct => {}
                    LangItem::AsyncDrop => {}
                    LangItem::AsyncDropInPlace => {}
                    LangItem::CoerceUnsized => {}
                    LangItem::DispatchFromDyn => {}
                    LangItem::TransmuteOpts => {}
                    LangItem::TransmuteTrait => {}
                    LangItem::Add => {}
                    LangItem::Sub => {}
                    LangItem::Mul => {}
                    LangItem::Div => {}
                    LangItem::Rem => {}
                    LangItem::Neg => {}
                    LangItem::Not => {}
                    LangItem::BitXor => {}
                    LangItem::BitAnd => {}
                    LangItem::BitOr => {}
                    LangItem::Shl => {}
                    LangItem::Shr => {}
                    LangItem::AddAssign => {}
                    LangItem::SubAssign => {}
                    LangItem::MulAssign => {}
                    LangItem::DivAssign => {}
                    LangItem::RemAssign => {}
                    LangItem::BitXorAssign => {}
                    LangItem::BitAndAssign => {}
                    LangItem::BitOrAssign => {}
                    LangItem::ShlAssign => {}
                    LangItem::ShrAssign => {}
                    LangItem::Index => {}
                    LangItem::IndexMut => {}
                    LangItem::UnsafeCell => {}
                    LangItem::UnsafePinned => {}
                    LangItem::VaList => {}
                    LangItem::Deref => {}
                    LangItem::DerefMut => {}
                    LangItem::DerefPure => {}
                    LangItem::DerefTarget => {}
                    LangItem::Receiver => {}
                    LangItem::ReceiverTarget => {}
                    LangItem::LegacyReceiver => {}
                    LangItem::Fn => {}
                    LangItem::FnMut => {}
                    LangItem::FnOnce => {}
                    LangItem::AsyncFn => {}
                    LangItem::AsyncFnMut => {}
                    LangItem::AsyncFnOnce => {}
                    LangItem::AsyncFnOnceOutput => {}
                    LangItem::CallOnceFuture => {}
                    LangItem::CallRefFuture => {}
                    LangItem::AsyncFnKindHelper => {}
                    LangItem::AsyncFnKindUpvars => {}
                    LangItem::FnOnceOutput => {}
                    LangItem::Iterator => {}
                    LangItem::FusedIterator => {}
                    LangItem::Future => {}
                    LangItem::FutureOutput => {}
                    LangItem::AsyncIterator => {}
                    LangItem::CoroutineState => {}
                    LangItem::Coroutine => {}
                    LangItem::CoroutineReturn => {}
                    LangItem::CoroutineYield => {}
                    LangItem::CoroutineResume => {}
                    LangItem::Unpin => {}
                    LangItem::Pin => {}
                    LangItem::OrderingEnum => {}
                    LangItem::PartialEq => {}
                    LangItem::PartialOrd => {}
                    LangItem::CVoid => {}
                    LangItem::Type => {}
                    LangItem::TypeId => {}
                    LangItem::Panic => {}
                    LangItem::PanicNounwind => {}
                    LangItem::PanicFmt => {}
                    LangItem::PanicDisplay => {}
                    LangItem::ConstPanicFmt => {}
                    LangItem::PanicBoundsCheck => {}
                    LangItem::PanicMisalignedPointerDereference => {}
                    LangItem::PanicInfo => {}
                    LangItem::PanicLocation => {}
                    LangItem::PanicImpl => {}
                    LangItem::PanicCannotUnwind => {}
                    LangItem::PanicInCleanup => {}
                    LangItem::PanicAddOverflow => {}
                    LangItem::PanicSubOverflow => {}
                    LangItem::PanicMulOverflow => {}
                    LangItem::PanicDivOverflow => {}
                    LangItem::PanicRemOverflow => {}
                    LangItem::PanicNegOverflow => {}
                    LangItem::PanicShrOverflow => {}
                    LangItem::PanicShlOverflow => {}
                    LangItem::PanicDivZero => {}
                    LangItem::PanicRemZero => {}
                    LangItem::PanicCoroutineResumed => {}
                    LangItem::PanicAsyncFnResumed => {}
                    LangItem::PanicAsyncGenFnResumed => {}
                    LangItem::PanicGenFnNone => {}
                    LangItem::PanicCoroutineResumedPanic => {}
                    LangItem::PanicAsyncFnResumedPanic => {}
                    LangItem::PanicAsyncGenFnResumedPanic => {}
                    LangItem::PanicGenFnNonePanic => {}
                    LangItem::PanicNullPointerDereference => {}
                    LangItem::PanicInvalidEnumConstruction => {}
                    LangItem::PanicCoroutineResumedDrop => {}
                    LangItem::PanicAsyncFnResumedDrop => {}
                    LangItem::PanicAsyncGenFnResumedDrop => {}
                    LangItem::PanicGenFnNoneDrop => {}
                    LangItem::BeginPanic => {}
                    LangItem::FormatArgument => {}
                    LangItem::FormatArguments => {}
                    LangItem::ExchangeMalloc => {}
                    LangItem::DropInPlace => {}
                    LangItem::AllocLayout => {}
                    LangItem::Start => {}
                    LangItem::EhPersonality => {}
                    LangItem::EhCatchTypeinfo => {}
                    LangItem::CompilerMove => {}
                    LangItem::CompilerCopy => {}
                    LangItem::OwnedBox => {}
                    LangItem::GlobalAlloc => {}
                    LangItem::PhantomData => {}
                    LangItem::ManuallyDrop => {}
                    LangItem::BikeshedGuaranteedNoDrop => {}
                    LangItem::MaybeUninit => {}
                    LangItem::Termination => {}
                    LangItem::Try => {}
                    LangItem::Tuple => {}
                    LangItem::SliceLen => {}
                    LangItem::TryTraitFromResidual => {}
                    LangItem::TryTraitFromOutput => {}
                    LangItem::TryTraitBranch => {}
                    LangItem::TryTraitFromYeet => {}
                    LangItem::ResidualIntoTryType => {}
                    LangItem::CoercePointeeValidated => {}
                    LangItem::ConstParamTy => {}
                    LangItem::Poll => {}
                    LangItem::PollReady => {}
                    LangItem::PollPending => {}
                    LangItem::AsyncGenReady => {}
                    LangItem::AsyncGenPending => {}
                    LangItem::AsyncGenFinished => {}
                    LangItem::ResumeTy => {}
                    LangItem::GetContext => {}
                    LangItem::Context => {}
                    LangItem::FuturePoll => {}
                    LangItem::AsyncIteratorPollNext => {}
                    LangItem::IntoAsyncIterIntoIter => {}
                    LangItem::Option => {}
                    LangItem::OptionSome => {}
                    LangItem::OptionNone => {}
                    LangItem::ResultOk => {}
                    LangItem::ResultErr => {}
                    LangItem::ControlFlowContinue => {}
                    LangItem::ControlFlowBreak => {}
                    LangItem::IntoFutureIntoFuture => {}
                    LangItem::IntoIterIntoIter => {}
                    LangItem::IteratorNext => {}
                    LangItem::PinNewUnchecked => {}
                    LangItem::RangeFrom => {}
                    LangItem::RangeFull => {}
                    LangItem::RangeInclusiveStruct => {}
                    LangItem::RangeInclusiveNew => {}
                    LangItem::Range => {}
                    LangItem::RangeToInclusive => {}
                    LangItem::RangeTo => {}
                    LangItem::RangeMax => {}
                    LangItem::RangeMin => {}
                    LangItem::RangeSub => {}
                    LangItem::RangeFromCopy => {}
                    LangItem::RangeCopy => {}
                    LangItem::RangeInclusiveCopy => {}
                    LangItem::RangeToInclusiveCopy => {}
                    LangItem::String => {}
                    LangItem::CStr => {}
                    LangItem::ContractBuildCheckEnsures => {}
                    LangItem::ContractCheckRequires => {}
                    LangItem::DefaultTrait4 => {}
                    LangItem::DefaultTrait3 => {}
                    LangItem::DefaultTrait2 => {}
                    LangItem::DefaultTrait1 => {}
                    LangItem::ContractCheckEnsures => {}
                    LangItem::Reborrow => {}
                    LangItem::CoerceShared => {}
                }
            }
        }
    };
const _: () =
    {
        impl<__D: ::rustc_span::BlobDecoder> ::rustc_serialize::Decodable<__D>
            for LangItem {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { LangItem::Sized }
                    1usize => { LangItem::MetaSized }
                    2usize => { LangItem::PointeeSized }
                    3usize => { LangItem::Unsize }
                    4usize => { LangItem::AlignOf }
                    5usize => { LangItem::SizeOf }
                    6usize => { LangItem::OffsetOf }
                    7usize => { LangItem::StructuralPeq }
                    8usize => { LangItem::Copy }
                    9usize => { LangItem::Clone }
                    10usize => { LangItem::CloneFn }
                    11usize => { LangItem::UseCloned }
                    12usize => { LangItem::TrivialClone }
                    13usize => { LangItem::Sync }
                    14usize => { LangItem::DiscriminantKind }
                    15usize => { LangItem::Discriminant }
                    16usize => { LangItem::PointeeTrait }
                    17usize => { LangItem::Metadata }
                    18usize => { LangItem::DynMetadata }
                    19usize => { LangItem::Freeze }
                    20usize => { LangItem::UnsafeUnpin }
                    21usize => { LangItem::FnPtrTrait }
                    22usize => { LangItem::FnPtrAddr }
                    23usize => { LangItem::Drop }
                    24usize => { LangItem::Destruct }
                    25usize => { LangItem::AsyncDrop }
                    26usize => { LangItem::AsyncDropInPlace }
                    27usize => { LangItem::CoerceUnsized }
                    28usize => { LangItem::DispatchFromDyn }
                    29usize => { LangItem::TransmuteOpts }
                    30usize => { LangItem::TransmuteTrait }
                    31usize => { LangItem::Add }
                    32usize => { LangItem::Sub }
                    33usize => { LangItem::Mul }
                    34usize => { LangItem::Div }
                    35usize => { LangItem::Rem }
                    36usize => { LangItem::Neg }
                    37usize => { LangItem::Not }
                    38usize => { LangItem::BitXor }
                    39usize => { LangItem::BitAnd }
                    40usize => { LangItem::BitOr }
                    41usize => { LangItem::Shl }
                    42usize => { LangItem::Shr }
                    43usize => { LangItem::AddAssign }
                    44usize => { LangItem::SubAssign }
                    45usize => { LangItem::MulAssign }
                    46usize => { LangItem::DivAssign }
                    47usize => { LangItem::RemAssign }
                    48usize => { LangItem::BitXorAssign }
                    49usize => { LangItem::BitAndAssign }
                    50usize => { LangItem::BitOrAssign }
                    51usize => { LangItem::ShlAssign }
                    52usize => { LangItem::ShrAssign }
                    53usize => { LangItem::Index }
                    54usize => { LangItem::IndexMut }
                    55usize => { LangItem::UnsafeCell }
                    56usize => { LangItem::UnsafePinned }
                    57usize => { LangItem::VaList }
                    58usize => { LangItem::Deref }
                    59usize => { LangItem::DerefMut }
                    60usize => { LangItem::DerefPure }
                    61usize => { LangItem::DerefTarget }
                    62usize => { LangItem::Receiver }
                    63usize => { LangItem::ReceiverTarget }
                    64usize => { LangItem::LegacyReceiver }
                    65usize => { LangItem::Fn }
                    66usize => { LangItem::FnMut }
                    67usize => { LangItem::FnOnce }
                    68usize => { LangItem::AsyncFn }
                    69usize => { LangItem::AsyncFnMut }
                    70usize => { LangItem::AsyncFnOnce }
                    71usize => { LangItem::AsyncFnOnceOutput }
                    72usize => { LangItem::CallOnceFuture }
                    73usize => { LangItem::CallRefFuture }
                    74usize => { LangItem::AsyncFnKindHelper }
                    75usize => { LangItem::AsyncFnKindUpvars }
                    76usize => { LangItem::FnOnceOutput }
                    77usize => { LangItem::Iterator }
                    78usize => { LangItem::FusedIterator }
                    79usize => { LangItem::Future }
                    80usize => { LangItem::FutureOutput }
                    81usize => { LangItem::AsyncIterator }
                    82usize => { LangItem::CoroutineState }
                    83usize => { LangItem::Coroutine }
                    84usize => { LangItem::CoroutineReturn }
                    85usize => { LangItem::CoroutineYield }
                    86usize => { LangItem::CoroutineResume }
                    87usize => { LangItem::Unpin }
                    88usize => { LangItem::Pin }
                    89usize => { LangItem::OrderingEnum }
                    90usize => { LangItem::PartialEq }
                    91usize => { LangItem::PartialOrd }
                    92usize => { LangItem::CVoid }
                    93usize => { LangItem::Type }
                    94usize => { LangItem::TypeId }
                    95usize => { LangItem::Panic }
                    96usize => { LangItem::PanicNounwind }
                    97usize => { LangItem::PanicFmt }
                    98usize => { LangItem::PanicDisplay }
                    99usize => { LangItem::ConstPanicFmt }
                    100usize => { LangItem::PanicBoundsCheck }
                    101usize => { LangItem::PanicMisalignedPointerDereference }
                    102usize => { LangItem::PanicInfo }
                    103usize => { LangItem::PanicLocation }
                    104usize => { LangItem::PanicImpl }
                    105usize => { LangItem::PanicCannotUnwind }
                    106usize => { LangItem::PanicInCleanup }
                    107usize => { LangItem::PanicAddOverflow }
                    108usize => { LangItem::PanicSubOverflow }
                    109usize => { LangItem::PanicMulOverflow }
                    110usize => { LangItem::PanicDivOverflow }
                    111usize => { LangItem::PanicRemOverflow }
                    112usize => { LangItem::PanicNegOverflow }
                    113usize => { LangItem::PanicShrOverflow }
                    114usize => { LangItem::PanicShlOverflow }
                    115usize => { LangItem::PanicDivZero }
                    116usize => { LangItem::PanicRemZero }
                    117usize => { LangItem::PanicCoroutineResumed }
                    118usize => { LangItem::PanicAsyncFnResumed }
                    119usize => { LangItem::PanicAsyncGenFnResumed }
                    120usize => { LangItem::PanicGenFnNone }
                    121usize => { LangItem::PanicCoroutineResumedPanic }
                    122usize => { LangItem::PanicAsyncFnResumedPanic }
                    123usize => { LangItem::PanicAsyncGenFnResumedPanic }
                    124usize => { LangItem::PanicGenFnNonePanic }
                    125usize => { LangItem::PanicNullPointerDereference }
                    126usize => { LangItem::PanicInvalidEnumConstruction }
                    127usize => { LangItem::PanicCoroutineResumedDrop }
                    128usize => { LangItem::PanicAsyncFnResumedDrop }
                    129usize => { LangItem::PanicAsyncGenFnResumedDrop }
                    130usize => { LangItem::PanicGenFnNoneDrop }
                    131usize => { LangItem::BeginPanic }
                    132usize => { LangItem::FormatArgument }
                    133usize => { LangItem::FormatArguments }
                    134usize => { LangItem::ExchangeMalloc }
                    135usize => { LangItem::DropInPlace }
                    136usize => { LangItem::AllocLayout }
                    137usize => { LangItem::Start }
                    138usize => { LangItem::EhPersonality }
                    139usize => { LangItem::EhCatchTypeinfo }
                    140usize => { LangItem::CompilerMove }
                    141usize => { LangItem::CompilerCopy }
                    142usize => { LangItem::OwnedBox }
                    143usize => { LangItem::GlobalAlloc }
                    144usize => { LangItem::PhantomData }
                    145usize => { LangItem::ManuallyDrop }
                    146usize => { LangItem::BikeshedGuaranteedNoDrop }
                    147usize => { LangItem::MaybeUninit }
                    148usize => { LangItem::Termination }
                    149usize => { LangItem::Try }
                    150usize => { LangItem::Tuple }
                    151usize => { LangItem::SliceLen }
                    152usize => { LangItem::TryTraitFromResidual }
                    153usize => { LangItem::TryTraitFromOutput }
                    154usize => { LangItem::TryTraitBranch }
                    155usize => { LangItem::TryTraitFromYeet }
                    156usize => { LangItem::ResidualIntoTryType }
                    157usize => { LangItem::CoercePointeeValidated }
                    158usize => { LangItem::ConstParamTy }
                    159usize => { LangItem::Poll }
                    160usize => { LangItem::PollReady }
                    161usize => { LangItem::PollPending }
                    162usize => { LangItem::AsyncGenReady }
                    163usize => { LangItem::AsyncGenPending }
                    164usize => { LangItem::AsyncGenFinished }
                    165usize => { LangItem::ResumeTy }
                    166usize => { LangItem::GetContext }
                    167usize => { LangItem::Context }
                    168usize => { LangItem::FuturePoll }
                    169usize => { LangItem::AsyncIteratorPollNext }
                    170usize => { LangItem::IntoAsyncIterIntoIter }
                    171usize => { LangItem::Option }
                    172usize => { LangItem::OptionSome }
                    173usize => { LangItem::OptionNone }
                    174usize => { LangItem::ResultOk }
                    175usize => { LangItem::ResultErr }
                    176usize => { LangItem::ControlFlowContinue }
                    177usize => { LangItem::ControlFlowBreak }
                    178usize => { LangItem::IntoFutureIntoFuture }
                    179usize => { LangItem::IntoIterIntoIter }
                    180usize => { LangItem::IteratorNext }
                    181usize => { LangItem::PinNewUnchecked }
                    182usize => { LangItem::RangeFrom }
                    183usize => { LangItem::RangeFull }
                    184usize => { LangItem::RangeInclusiveStruct }
                    185usize => { LangItem::RangeInclusiveNew }
                    186usize => { LangItem::Range }
                    187usize => { LangItem::RangeToInclusive }
                    188usize => { LangItem::RangeTo }
                    189usize => { LangItem::RangeMax }
                    190usize => { LangItem::RangeMin }
                    191usize => { LangItem::RangeSub }
                    192usize => { LangItem::RangeFromCopy }
                    193usize => { LangItem::RangeCopy }
                    194usize => { LangItem::RangeInclusiveCopy }
                    195usize => { LangItem::RangeToInclusiveCopy }
                    196usize => { LangItem::String }
                    197usize => { LangItem::CStr }
                    198usize => { LangItem::ContractBuildCheckEnsures }
                    199usize => { LangItem::ContractCheckRequires }
                    200usize => { LangItem::DefaultTrait4 }
                    201usize => { LangItem::DefaultTrait3 }
                    202usize => { LangItem::DefaultTrait2 }
                    203usize => { LangItem::DefaultTrait1 }
                    204usize => { LangItem::ContractCheckEnsures }
                    205usize => { LangItem::Reborrow }
                    206usize => { LangItem::CoerceShared }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `LangItem`, expected 0..207, actual {0}",
                                n));
                    }
                }
            }
        }
    };
impl LangItem {
    fn from_u32(u: u32) -> Option<LangItem> {
        if u == LangItem::Sized as u32 { return Some(LangItem::Sized) }
        if u == LangItem::MetaSized as u32 {
            return Some(LangItem::MetaSized)
        }
        if u == LangItem::PointeeSized as u32 {
            return Some(LangItem::PointeeSized)
        }
        if u == LangItem::Unsize as u32 { return Some(LangItem::Unsize) }
        if u == LangItem::AlignOf as u32 { return Some(LangItem::AlignOf) }
        if u == LangItem::SizeOf as u32 { return Some(LangItem::SizeOf) }
        if u == LangItem::OffsetOf as u32 { return Some(LangItem::OffsetOf) }
        if u == LangItem::StructuralPeq as u32 {
            return Some(LangItem::StructuralPeq)
        }
        if u == LangItem::Copy as u32 { return Some(LangItem::Copy) }
        if u == LangItem::Clone as u32 { return Some(LangItem::Clone) }
        if u == LangItem::CloneFn as u32 { return Some(LangItem::CloneFn) }
        if u == LangItem::UseCloned as u32 {
            return Some(LangItem::UseCloned)
        }
        if u == LangItem::TrivialClone as u32 {
            return Some(LangItem::TrivialClone)
        }
        if u == LangItem::Sync as u32 { return Some(LangItem::Sync) }
        if u == LangItem::DiscriminantKind as u32 {
            return Some(LangItem::DiscriminantKind)
        }
        if u == LangItem::Discriminant as u32 {
            return Some(LangItem::Discriminant)
        }
        if u == LangItem::PointeeTrait as u32 {
            return Some(LangItem::PointeeTrait)
        }
        if u == LangItem::Metadata as u32 { return Some(LangItem::Metadata) }
        if u == LangItem::DynMetadata as u32 {
            return Some(LangItem::DynMetadata)
        }
        if u == LangItem::Freeze as u32 { return Some(LangItem::Freeze) }
        if u == LangItem::UnsafeUnpin as u32 {
            return Some(LangItem::UnsafeUnpin)
        }
        if u == LangItem::FnPtrTrait as u32 {
            return Some(LangItem::FnPtrTrait)
        }
        if u == LangItem::FnPtrAddr as u32 {
            return Some(LangItem::FnPtrAddr)
        }
        if u == LangItem::Drop as u32 { return Some(LangItem::Drop) }
        if u == LangItem::Destruct as u32 { return Some(LangItem::Destruct) }
        if u == LangItem::AsyncDrop as u32 {
            return Some(LangItem::AsyncDrop)
        }
        if u == LangItem::AsyncDropInPlace as u32 {
            return Some(LangItem::AsyncDropInPlace)
        }
        if u == LangItem::CoerceUnsized as u32 {
            return Some(LangItem::CoerceUnsized)
        }
        if u == LangItem::DispatchFromDyn as u32 {
            return Some(LangItem::DispatchFromDyn)
        }
        if u == LangItem::TransmuteOpts as u32 {
            return Some(LangItem::TransmuteOpts)
        }
        if u == LangItem::TransmuteTrait as u32 {
            return Some(LangItem::TransmuteTrait)
        }
        if u == LangItem::Add as u32 { return Some(LangItem::Add) }
        if u == LangItem::Sub as u32 { return Some(LangItem::Sub) }
        if u == LangItem::Mul as u32 { return Some(LangItem::Mul) }
        if u == LangItem::Div as u32 { return Some(LangItem::Div) }
        if u == LangItem::Rem as u32 { return Some(LangItem::Rem) }
        if u == LangItem::Neg as u32 { return Some(LangItem::Neg) }
        if u == LangItem::Not as u32 { return Some(LangItem::Not) }
        if u == LangItem::BitXor as u32 { return Some(LangItem::BitXor) }
        if u == LangItem::BitAnd as u32 { return Some(LangItem::BitAnd) }
        if u == LangItem::BitOr as u32 { return Some(LangItem::BitOr) }
        if u == LangItem::Shl as u32 { return Some(LangItem::Shl) }
        if u == LangItem::Shr as u32 { return Some(LangItem::Shr) }
        if u == LangItem::AddAssign as u32 {
            return Some(LangItem::AddAssign)
        }
        if u == LangItem::SubAssign as u32 {
            return Some(LangItem::SubAssign)
        }
        if u == LangItem::MulAssign as u32 {
            return Some(LangItem::MulAssign)
        }
        if u == LangItem::DivAssign as u32 {
            return Some(LangItem::DivAssign)
        }
        if u == LangItem::RemAssign as u32 {
            return Some(LangItem::RemAssign)
        }
        if u == LangItem::BitXorAssign as u32 {
            return Some(LangItem::BitXorAssign)
        }
        if u == LangItem::BitAndAssign as u32 {
            return Some(LangItem::BitAndAssign)
        }
        if u == LangItem::BitOrAssign as u32 {
            return Some(LangItem::BitOrAssign)
        }
        if u == LangItem::ShlAssign as u32 {
            return Some(LangItem::ShlAssign)
        }
        if u == LangItem::ShrAssign as u32 {
            return Some(LangItem::ShrAssign)
        }
        if u == LangItem::Index as u32 { return Some(LangItem::Index) }
        if u == LangItem::IndexMut as u32 { return Some(LangItem::IndexMut) }
        if u == LangItem::UnsafeCell as u32 {
            return Some(LangItem::UnsafeCell)
        }
        if u == LangItem::UnsafePinned as u32 {
            return Some(LangItem::UnsafePinned)
        }
        if u == LangItem::VaList as u32 { return Some(LangItem::VaList) }
        if u == LangItem::Deref as u32 { return Some(LangItem::Deref) }
        if u == LangItem::DerefMut as u32 { return Some(LangItem::DerefMut) }
        if u == LangItem::DerefPure as u32 {
            return Some(LangItem::DerefPure)
        }
        if u == LangItem::DerefTarget as u32 {
            return Some(LangItem::DerefTarget)
        }
        if u == LangItem::Receiver as u32 { return Some(LangItem::Receiver) }
        if u == LangItem::ReceiverTarget as u32 {
            return Some(LangItem::ReceiverTarget)
        }
        if u == LangItem::LegacyReceiver as u32 {
            return Some(LangItem::LegacyReceiver)
        }
        if u == LangItem::Fn as u32 { return Some(LangItem::Fn) }
        if u == LangItem::FnMut as u32 { return Some(LangItem::FnMut) }
        if u == LangItem::FnOnce as u32 { return Some(LangItem::FnOnce) }
        if u == LangItem::AsyncFn as u32 { return Some(LangItem::AsyncFn) }
        if u == LangItem::AsyncFnMut as u32 {
            return Some(LangItem::AsyncFnMut)
        }
        if u == LangItem::AsyncFnOnce as u32 {
            return Some(LangItem::AsyncFnOnce)
        }
        if u == LangItem::AsyncFnOnceOutput as u32 {
            return Some(LangItem::AsyncFnOnceOutput)
        }
        if u == LangItem::CallOnceFuture as u32 {
            return Some(LangItem::CallOnceFuture)
        }
        if u == LangItem::CallRefFuture as u32 {
            return Some(LangItem::CallRefFuture)
        }
        if u == LangItem::AsyncFnKindHelper as u32 {
            return Some(LangItem::AsyncFnKindHelper)
        }
        if u == LangItem::AsyncFnKindUpvars as u32 {
            return Some(LangItem::AsyncFnKindUpvars)
        }
        if u == LangItem::FnOnceOutput as u32 {
            return Some(LangItem::FnOnceOutput)
        }
        if u == LangItem::Iterator as u32 { return Some(LangItem::Iterator) }
        if u == LangItem::FusedIterator as u32 {
            return Some(LangItem::FusedIterator)
        }
        if u == LangItem::Future as u32 { return Some(LangItem::Future) }
        if u == LangItem::FutureOutput as u32 {
            return Some(LangItem::FutureOutput)
        }
        if u == LangItem::AsyncIterator as u32 {
            return Some(LangItem::AsyncIterator)
        }
        if u == LangItem::CoroutineState as u32 {
            return Some(LangItem::CoroutineState)
        }
        if u == LangItem::Coroutine as u32 {
            return Some(LangItem::Coroutine)
        }
        if u == LangItem::CoroutineReturn as u32 {
            return Some(LangItem::CoroutineReturn)
        }
        if u == LangItem::CoroutineYield as u32 {
            return Some(LangItem::CoroutineYield)
        }
        if u == LangItem::CoroutineResume as u32 {
            return Some(LangItem::CoroutineResume)
        }
        if u == LangItem::Unpin as u32 { return Some(LangItem::Unpin) }
        if u == LangItem::Pin as u32 { return Some(LangItem::Pin) }
        if u == LangItem::OrderingEnum as u32 {
            return Some(LangItem::OrderingEnum)
        }
        if u == LangItem::PartialEq as u32 {
            return Some(LangItem::PartialEq)
        }
        if u == LangItem::PartialOrd as u32 {
            return Some(LangItem::PartialOrd)
        }
        if u == LangItem::CVoid as u32 { return Some(LangItem::CVoid) }
        if u == LangItem::Type as u32 { return Some(LangItem::Type) }
        if u == LangItem::TypeId as u32 { return Some(LangItem::TypeId) }
        if u == LangItem::Panic as u32 { return Some(LangItem::Panic) }
        if u == LangItem::PanicNounwind as u32 {
            return Some(LangItem::PanicNounwind)
        }
        if u == LangItem::PanicFmt as u32 { return Some(LangItem::PanicFmt) }
        if u == LangItem::PanicDisplay as u32 {
            return Some(LangItem::PanicDisplay)
        }
        if u == LangItem::ConstPanicFmt as u32 {
            return Some(LangItem::ConstPanicFmt)
        }
        if u == LangItem::PanicBoundsCheck as u32 {
            return Some(LangItem::PanicBoundsCheck)
        }
        if u == LangItem::PanicMisalignedPointerDereference as u32 {
            return Some(LangItem::PanicMisalignedPointerDereference)
        }
        if u == LangItem::PanicInfo as u32 {
            return Some(LangItem::PanicInfo)
        }
        if u == LangItem::PanicLocation as u32 {
            return Some(LangItem::PanicLocation)
        }
        if u == LangItem::PanicImpl as u32 {
            return Some(LangItem::PanicImpl)
        }
        if u == LangItem::PanicCannotUnwind as u32 {
            return Some(LangItem::PanicCannotUnwind)
        }
        if u == LangItem::PanicInCleanup as u32 {
            return Some(LangItem::PanicInCleanup)
        }
        if u == LangItem::PanicAddOverflow as u32 {
            return Some(LangItem::PanicAddOverflow)
        }
        if u == LangItem::PanicSubOverflow as u32 {
            return Some(LangItem::PanicSubOverflow)
        }
        if u == LangItem::PanicMulOverflow as u32 {
            return Some(LangItem::PanicMulOverflow)
        }
        if u == LangItem::PanicDivOverflow as u32 {
            return Some(LangItem::PanicDivOverflow)
        }
        if u == LangItem::PanicRemOverflow as u32 {
            return Some(LangItem::PanicRemOverflow)
        }
        if u == LangItem::PanicNegOverflow as u32 {
            return Some(LangItem::PanicNegOverflow)
        }
        if u == LangItem::PanicShrOverflow as u32 {
            return Some(LangItem::PanicShrOverflow)
        }
        if u == LangItem::PanicShlOverflow as u32 {
            return Some(LangItem::PanicShlOverflow)
        }
        if u == LangItem::PanicDivZero as u32 {
            return Some(LangItem::PanicDivZero)
        }
        if u == LangItem::PanicRemZero as u32 {
            return Some(LangItem::PanicRemZero)
        }
        if u == LangItem::PanicCoroutineResumed as u32 {
            return Some(LangItem::PanicCoroutineResumed)
        }
        if u == LangItem::PanicAsyncFnResumed as u32 {
            return Some(LangItem::PanicAsyncFnResumed)
        }
        if u == LangItem::PanicAsyncGenFnResumed as u32 {
            return Some(LangItem::PanicAsyncGenFnResumed)
        }
        if u == LangItem::PanicGenFnNone as u32 {
            return Some(LangItem::PanicGenFnNone)
        }
        if u == LangItem::PanicCoroutineResumedPanic as u32 {
            return Some(LangItem::PanicCoroutineResumedPanic)
        }
        if u == LangItem::PanicAsyncFnResumedPanic as u32 {
            return Some(LangItem::PanicAsyncFnResumedPanic)
        }
        if u == LangItem::PanicAsyncGenFnResumedPanic as u32 {
            return Some(LangItem::PanicAsyncGenFnResumedPanic)
        }
        if u == LangItem::PanicGenFnNonePanic as u32 {
            return Some(LangItem::PanicGenFnNonePanic)
        }
        if u == LangItem::PanicNullPointerDereference as u32 {
            return Some(LangItem::PanicNullPointerDereference)
        }
        if u == LangItem::PanicInvalidEnumConstruction as u32 {
            return Some(LangItem::PanicInvalidEnumConstruction)
        }
        if u == LangItem::PanicCoroutineResumedDrop as u32 {
            return Some(LangItem::PanicCoroutineResumedDrop)
        }
        if u == LangItem::PanicAsyncFnResumedDrop as u32 {
            return Some(LangItem::PanicAsyncFnResumedDrop)
        }
        if u == LangItem::PanicAsyncGenFnResumedDrop as u32 {
            return Some(LangItem::PanicAsyncGenFnResumedDrop)
        }
        if u == LangItem::PanicGenFnNoneDrop as u32 {
            return Some(LangItem::PanicGenFnNoneDrop)
        }
        if u == LangItem::BeginPanic as u32 {
            return Some(LangItem::BeginPanic)
        }
        if u == LangItem::FormatArgument as u32 {
            return Some(LangItem::FormatArgument)
        }
        if u == LangItem::FormatArguments as u32 {
            return Some(LangItem::FormatArguments)
        }
        if u == LangItem::ExchangeMalloc as u32 {
            return Some(LangItem::ExchangeMalloc)
        }
        if u == LangItem::DropInPlace as u32 {
            return Some(LangItem::DropInPlace)
        }
        if u == LangItem::AllocLayout as u32 {
            return Some(LangItem::AllocLayout)
        }
        if u == LangItem::Start as u32 { return Some(LangItem::Start) }
        if u == LangItem::EhPersonality as u32 {
            return Some(LangItem::EhPersonality)
        }
        if u == LangItem::EhCatchTypeinfo as u32 {
            return Some(LangItem::EhCatchTypeinfo)
        }
        if u == LangItem::CompilerMove as u32 {
            return Some(LangItem::CompilerMove)
        }
        if u == LangItem::CompilerCopy as u32 {
            return Some(LangItem::CompilerCopy)
        }
        if u == LangItem::OwnedBox as u32 { return Some(LangItem::OwnedBox) }
        if u == LangItem::GlobalAlloc as u32 {
            return Some(LangItem::GlobalAlloc)
        }
        if u == LangItem::PhantomData as u32 {
            return Some(LangItem::PhantomData)
        }
        if u == LangItem::ManuallyDrop as u32 {
            return Some(LangItem::ManuallyDrop)
        }
        if u == LangItem::BikeshedGuaranteedNoDrop as u32 {
            return Some(LangItem::BikeshedGuaranteedNoDrop)
        }
        if u == LangItem::MaybeUninit as u32 {
            return Some(LangItem::MaybeUninit)
        }
        if u == LangItem::Termination as u32 {
            return Some(LangItem::Termination)
        }
        if u == LangItem::Try as u32 { return Some(LangItem::Try) }
        if u == LangItem::Tuple as u32 { return Some(LangItem::Tuple) }
        if u == LangItem::SliceLen as u32 { return Some(LangItem::SliceLen) }
        if u == LangItem::TryTraitFromResidual as u32 {
            return Some(LangItem::TryTraitFromResidual)
        }
        if u == LangItem::TryTraitFromOutput as u32 {
            return Some(LangItem::TryTraitFromOutput)
        }
        if u == LangItem::TryTraitBranch as u32 {
            return Some(LangItem::TryTraitBranch)
        }
        if u == LangItem::TryTraitFromYeet as u32 {
            return Some(LangItem::TryTraitFromYeet)
        }
        if u == LangItem::ResidualIntoTryType as u32 {
            return Some(LangItem::ResidualIntoTryType)
        }
        if u == LangItem::CoercePointeeValidated as u32 {
            return Some(LangItem::CoercePointeeValidated)
        }
        if u == LangItem::ConstParamTy as u32 {
            return Some(LangItem::ConstParamTy)
        }
        if u == LangItem::Poll as u32 { return Some(LangItem::Poll) }
        if u == LangItem::PollReady as u32 {
            return Some(LangItem::PollReady)
        }
        if u == LangItem::PollPending as u32 {
            return Some(LangItem::PollPending)
        }
        if u == LangItem::AsyncGenReady as u32 {
            return Some(LangItem::AsyncGenReady)
        }
        if u == LangItem::AsyncGenPending as u32 {
            return Some(LangItem::AsyncGenPending)
        }
        if u == LangItem::AsyncGenFinished as u32 {
            return Some(LangItem::AsyncGenFinished)
        }
        if u == LangItem::ResumeTy as u32 { return Some(LangItem::ResumeTy) }
        if u == LangItem::GetContext as u32 {
            return Some(LangItem::GetContext)
        }
        if u == LangItem::Context as u32 { return Some(LangItem::Context) }
        if u == LangItem::FuturePoll as u32 {
            return Some(LangItem::FuturePoll)
        }
        if u == LangItem::AsyncIteratorPollNext as u32 {
            return Some(LangItem::AsyncIteratorPollNext)
        }
        if u == LangItem::IntoAsyncIterIntoIter as u32 {
            return Some(LangItem::IntoAsyncIterIntoIter)
        }
        if u == LangItem::Option as u32 { return Some(LangItem::Option) }
        if u == LangItem::OptionSome as u32 {
            return Some(LangItem::OptionSome)
        }
        if u == LangItem::OptionNone as u32 {
            return Some(LangItem::OptionNone)
        }
        if u == LangItem::ResultOk as u32 { return Some(LangItem::ResultOk) }
        if u == LangItem::ResultErr as u32 {
            return Some(LangItem::ResultErr)
        }
        if u == LangItem::ControlFlowContinue as u32 {
            return Some(LangItem::ControlFlowContinue)
        }
        if u == LangItem::ControlFlowBreak as u32 {
            return Some(LangItem::ControlFlowBreak)
        }
        if u == LangItem::IntoFutureIntoFuture as u32 {
            return Some(LangItem::IntoFutureIntoFuture)
        }
        if u == LangItem::IntoIterIntoIter as u32 {
            return Some(LangItem::IntoIterIntoIter)
        }
        if u == LangItem::IteratorNext as u32 {
            return Some(LangItem::IteratorNext)
        }
        if u == LangItem::PinNewUnchecked as u32 {
            return Some(LangItem::PinNewUnchecked)
        }
        if u == LangItem::RangeFrom as u32 {
            return Some(LangItem::RangeFrom)
        }
        if u == LangItem::RangeFull as u32 {
            return Some(LangItem::RangeFull)
        }
        if u == LangItem::RangeInclusiveStruct as u32 {
            return Some(LangItem::RangeInclusiveStruct)
        }
        if u == LangItem::RangeInclusiveNew as u32 {
            return Some(LangItem::RangeInclusiveNew)
        }
        if u == LangItem::Range as u32 { return Some(LangItem::Range) }
        if u == LangItem::RangeToInclusive as u32 {
            return Some(LangItem::RangeToInclusive)
        }
        if u == LangItem::RangeTo as u32 { return Some(LangItem::RangeTo) }
        if u == LangItem::RangeMax as u32 { return Some(LangItem::RangeMax) }
        if u == LangItem::RangeMin as u32 { return Some(LangItem::RangeMin) }
        if u == LangItem::RangeSub as u32 { return Some(LangItem::RangeSub) }
        if u == LangItem::RangeFromCopy as u32 {
            return Some(LangItem::RangeFromCopy)
        }
        if u == LangItem::RangeCopy as u32 {
            return Some(LangItem::RangeCopy)
        }
        if u == LangItem::RangeInclusiveCopy as u32 {
            return Some(LangItem::RangeInclusiveCopy)
        }
        if u == LangItem::RangeToInclusiveCopy as u32 {
            return Some(LangItem::RangeToInclusiveCopy)
        }
        if u == LangItem::String as u32 { return Some(LangItem::String) }
        if u == LangItem::CStr as u32 { return Some(LangItem::CStr) }
        if u == LangItem::ContractBuildCheckEnsures as u32 {
            return Some(LangItem::ContractBuildCheckEnsures)
        }
        if u == LangItem::ContractCheckRequires as u32 {
            return Some(LangItem::ContractCheckRequires)
        }
        if u == LangItem::DefaultTrait4 as u32 {
            return Some(LangItem::DefaultTrait4)
        }
        if u == LangItem::DefaultTrait3 as u32 {
            return Some(LangItem::DefaultTrait3)
        }
        if u == LangItem::DefaultTrait2 as u32 {
            return Some(LangItem::DefaultTrait2)
        }
        if u == LangItem::DefaultTrait1 as u32 {
            return Some(LangItem::DefaultTrait1)
        }
        if u == LangItem::ContractCheckEnsures as u32 {
            return Some(LangItem::ContractCheckEnsures)
        }
        if u == LangItem::Reborrow as u32 { return Some(LangItem::Reborrow) }
        if u == LangItem::CoerceShared as u32 {
            return Some(LangItem::CoerceShared)
        }
        None
    }
    /// Returns the `name` symbol in `#[lang = "$name"]`.
    /// For example, [`LangItem::PartialEq`]`.name()`
    /// would result in [`sym::eq`] since it is `#[lang = "eq"]`.
    pub fn name(self) -> Symbol {
        match self {
            LangItem::Sized => sym::sized,
            LangItem::MetaSized => sym::meta_sized,
            LangItem::PointeeSized => sym::pointee_sized,
            LangItem::Unsize => sym::unsize,
            LangItem::AlignOf => sym::mem_align_const,
            LangItem::SizeOf => sym::mem_size_const,
            LangItem::OffsetOf => sym::offset_of,
            LangItem::StructuralPeq => sym::structural_peq,
            LangItem::Copy => sym::copy,
            LangItem::Clone => sym::clone,
            LangItem::CloneFn => sym::clone_fn,
            LangItem::UseCloned => sym::use_cloned,
            LangItem::TrivialClone => sym::trivial_clone,
            LangItem::Sync => sym::sync,
            LangItem::DiscriminantKind => sym::discriminant_kind,
            LangItem::Discriminant => sym::discriminant_type,
            LangItem::PointeeTrait => sym::pointee_trait,
            LangItem::Metadata => sym::metadata_type,
            LangItem::DynMetadata => sym::dyn_metadata,
            LangItem::Freeze => sym::freeze,
            LangItem::UnsafeUnpin => sym::unsafe_unpin,
            LangItem::FnPtrTrait => sym::fn_ptr_trait,
            LangItem::FnPtrAddr => sym::fn_ptr_addr,
            LangItem::Drop => sym::drop,
            LangItem::Destruct => sym::destruct,
            LangItem::AsyncDrop => sym::async_drop,
            LangItem::AsyncDropInPlace => sym::async_drop_in_place,
            LangItem::CoerceUnsized => sym::coerce_unsized,
            LangItem::DispatchFromDyn => sym::dispatch_from_dyn,
            LangItem::TransmuteOpts => sym::transmute_opts,
            LangItem::TransmuteTrait => sym::transmute_trait,
            LangItem::Add => sym::add,
            LangItem::Sub => sym::sub,
            LangItem::Mul => sym::mul,
            LangItem::Div => sym::div,
            LangItem::Rem => sym::rem,
            LangItem::Neg => sym::neg,
            LangItem::Not => sym::not,
            LangItem::BitXor => sym::bitxor,
            LangItem::BitAnd => sym::bitand,
            LangItem::BitOr => sym::bitor,
            LangItem::Shl => sym::shl,
            LangItem::Shr => sym::shr,
            LangItem::AddAssign => sym::add_assign,
            LangItem::SubAssign => sym::sub_assign,
            LangItem::MulAssign => sym::mul_assign,
            LangItem::DivAssign => sym::div_assign,
            LangItem::RemAssign => sym::rem_assign,
            LangItem::BitXorAssign => sym::bitxor_assign,
            LangItem::BitAndAssign => sym::bitand_assign,
            LangItem::BitOrAssign => sym::bitor_assign,
            LangItem::ShlAssign => sym::shl_assign,
            LangItem::ShrAssign => sym::shr_assign,
            LangItem::Index => sym::index,
            LangItem::IndexMut => sym::index_mut,
            LangItem::UnsafeCell => sym::unsafe_cell,
            LangItem::UnsafePinned => sym::unsafe_pinned,
            LangItem::VaList => sym::va_list,
            LangItem::Deref => sym::deref,
            LangItem::DerefMut => sym::deref_mut,
            LangItem::DerefPure => sym::deref_pure,
            LangItem::DerefTarget => sym::deref_target,
            LangItem::Receiver => sym::receiver,
            LangItem::ReceiverTarget => sym::receiver_target,
            LangItem::LegacyReceiver => sym::legacy_receiver,
            LangItem::Fn => kw::Fn,
            LangItem::FnMut => sym::fn_mut,
            LangItem::FnOnce => sym::fn_once,
            LangItem::AsyncFn => sym::async_fn,
            LangItem::AsyncFnMut => sym::async_fn_mut,
            LangItem::AsyncFnOnce => sym::async_fn_once,
            LangItem::AsyncFnOnceOutput => sym::async_fn_once_output,
            LangItem::CallOnceFuture => sym::call_once_future,
            LangItem::CallRefFuture => sym::call_ref_future,
            LangItem::AsyncFnKindHelper => sym::async_fn_kind_helper,
            LangItem::AsyncFnKindUpvars => sym::async_fn_kind_upvars,
            LangItem::FnOnceOutput => sym::fn_once_output,
            LangItem::Iterator => sym::iterator,
            LangItem::FusedIterator => sym::fused_iterator,
            LangItem::Future => sym::future_trait,
            LangItem::FutureOutput => sym::future_output,
            LangItem::AsyncIterator => sym::async_iterator,
            LangItem::CoroutineState => sym::coroutine_state,
            LangItem::Coroutine => sym::coroutine,
            LangItem::CoroutineReturn => sym::coroutine_return,
            LangItem::CoroutineYield => sym::coroutine_yield,
            LangItem::CoroutineResume => sym::coroutine_resume,
            LangItem::Unpin => sym::unpin,
            LangItem::Pin => sym::pin,
            LangItem::OrderingEnum => sym::Ordering,
            LangItem::PartialEq => sym::eq,
            LangItem::PartialOrd => sym::partial_ord,
            LangItem::CVoid => sym::c_void,
            LangItem::Type => sym::type_info,
            LangItem::TypeId => sym::type_id,
            LangItem::Panic => sym::panic,
            LangItem::PanicNounwind => sym::panic_nounwind,
            LangItem::PanicFmt => sym::panic_fmt,
            LangItem::PanicDisplay => sym::panic_display,
            LangItem::ConstPanicFmt => sym::const_panic_fmt,
            LangItem::PanicBoundsCheck => sym::panic_bounds_check,
            LangItem::PanicMisalignedPointerDereference =>
                sym::panic_misaligned_pointer_dereference,
            LangItem::PanicInfo => sym::panic_info,
            LangItem::PanicLocation => sym::panic_location,
            LangItem::PanicImpl => sym::panic_impl,
            LangItem::PanicCannotUnwind => sym::panic_cannot_unwind,
            LangItem::PanicInCleanup => sym::panic_in_cleanup,
            LangItem::PanicAddOverflow => sym::panic_const_add_overflow,
            LangItem::PanicSubOverflow => sym::panic_const_sub_overflow,
            LangItem::PanicMulOverflow => sym::panic_const_mul_overflow,
            LangItem::PanicDivOverflow => sym::panic_const_div_overflow,
            LangItem::PanicRemOverflow => sym::panic_const_rem_overflow,
            LangItem::PanicNegOverflow => sym::panic_const_neg_overflow,
            LangItem::PanicShrOverflow => sym::panic_const_shr_overflow,
            LangItem::PanicShlOverflow => sym::panic_const_shl_overflow,
            LangItem::PanicDivZero => sym::panic_const_div_by_zero,
            LangItem::PanicRemZero => sym::panic_const_rem_by_zero,
            LangItem::PanicCoroutineResumed =>
                sym::panic_const_coroutine_resumed,
            LangItem::PanicAsyncFnResumed =>
                sym::panic_const_async_fn_resumed,
            LangItem::PanicAsyncGenFnResumed =>
                sym::panic_const_async_gen_fn_resumed,
            LangItem::PanicGenFnNone => sym::panic_const_gen_fn_none,
            LangItem::PanicCoroutineResumedPanic =>
                sym::panic_const_coroutine_resumed_panic,
            LangItem::PanicAsyncFnResumedPanic =>
                sym::panic_const_async_fn_resumed_panic,
            LangItem::PanicAsyncGenFnResumedPanic =>
                sym::panic_const_async_gen_fn_resumed_panic,
            LangItem::PanicGenFnNonePanic =>
                sym::panic_const_gen_fn_none_panic,
            LangItem::PanicNullPointerDereference =>
                sym::panic_null_pointer_dereference,
            LangItem::PanicInvalidEnumConstruction =>
                sym::panic_invalid_enum_construction,
            LangItem::PanicCoroutineResumedDrop =>
                sym::panic_const_coroutine_resumed_drop,
            LangItem::PanicAsyncFnResumedDrop =>
                sym::panic_const_async_fn_resumed_drop,
            LangItem::PanicAsyncGenFnResumedDrop =>
                sym::panic_const_async_gen_fn_resumed_drop,
            LangItem::PanicGenFnNoneDrop => sym::panic_const_gen_fn_none_drop,
            LangItem::BeginPanic => sym::begin_panic,
            LangItem::FormatArgument => sym::format_argument,
            LangItem::FormatArguments => sym::format_arguments,
            LangItem::ExchangeMalloc => sym::exchange_malloc,
            LangItem::DropInPlace => sym::drop_in_place,
            LangItem::AllocLayout => sym::alloc_layout,
            LangItem::Start => sym::start,
            LangItem::EhPersonality => sym::eh_personality,
            LangItem::EhCatchTypeinfo => sym::eh_catch_typeinfo,
            LangItem::CompilerMove => sym::compiler_move,
            LangItem::CompilerCopy => sym::compiler_copy,
            LangItem::OwnedBox => sym::owned_box,
            LangItem::GlobalAlloc => sym::global_alloc_ty,
            LangItem::PhantomData => sym::phantom_data,
            LangItem::ManuallyDrop => sym::manually_drop,
            LangItem::BikeshedGuaranteedNoDrop =>
                sym::bikeshed_guaranteed_no_drop,
            LangItem::MaybeUninit => sym::maybe_uninit,
            LangItem::Termination => sym::termination,
            LangItem::Try => sym::Try,
            LangItem::Tuple => sym::tuple_trait,
            LangItem::SliceLen => sym::slice_len_fn,
            LangItem::TryTraitFromResidual => sym::from_residual,
            LangItem::TryTraitFromOutput => sym::from_output,
            LangItem::TryTraitBranch => sym::branch,
            LangItem::TryTraitFromYeet => sym::from_yeet,
            LangItem::ResidualIntoTryType => sym::into_try_type,
            LangItem::CoercePointeeValidated => sym::coerce_pointee_validated,
            LangItem::ConstParamTy => sym::const_param_ty,
            LangItem::Poll => sym::Poll,
            LangItem::PollReady => sym::Ready,
            LangItem::PollPending => sym::Pending,
            LangItem::AsyncGenReady => sym::AsyncGenReady,
            LangItem::AsyncGenPending => sym::AsyncGenPending,
            LangItem::AsyncGenFinished => sym::AsyncGenFinished,
            LangItem::ResumeTy => sym::ResumeTy,
            LangItem::GetContext => sym::get_context,
            LangItem::Context => sym::Context,
            LangItem::FuturePoll => sym::poll,
            LangItem::AsyncIteratorPollNext => sym::async_iterator_poll_next,
            LangItem::IntoAsyncIterIntoIter => sym::into_async_iter_into_iter,
            LangItem::Option => sym::Option,
            LangItem::OptionSome => sym::Some,
            LangItem::OptionNone => sym::None,
            LangItem::ResultOk => sym::Ok,
            LangItem::ResultErr => sym::Err,
            LangItem::ControlFlowContinue => sym::Continue,
            LangItem::ControlFlowBreak => sym::Break,
            LangItem::IntoFutureIntoFuture => sym::into_future,
            LangItem::IntoIterIntoIter => sym::into_iter,
            LangItem::IteratorNext => sym::next,
            LangItem::PinNewUnchecked => sym::new_unchecked,
            LangItem::RangeFrom => sym::RangeFrom,
            LangItem::RangeFull => sym::RangeFull,
            LangItem::RangeInclusiveStruct => sym::RangeInclusive,
            LangItem::RangeInclusiveNew => sym::range_inclusive_new,
            LangItem::Range => sym::Range,
            LangItem::RangeToInclusive => sym::RangeToInclusive,
            LangItem::RangeTo => sym::RangeTo,
            LangItem::RangeMax => sym::RangeMax,
            LangItem::RangeMin => sym::RangeMin,
            LangItem::RangeSub => sym::RangeSub,
            LangItem::RangeFromCopy => sym::RangeFromCopy,
            LangItem::RangeCopy => sym::RangeCopy,
            LangItem::RangeInclusiveCopy => sym::RangeInclusiveCopy,
            LangItem::RangeToInclusiveCopy => sym::RangeToInclusiveCopy,
            LangItem::String => sym::String,
            LangItem::CStr => sym::CStr,
            LangItem::ContractBuildCheckEnsures =>
                sym::contract_build_check_ensures,
            LangItem::ContractCheckRequires => sym::contract_check_requires,
            LangItem::DefaultTrait4 => sym::default_trait4,
            LangItem::DefaultTrait3 => sym::default_trait3,
            LangItem::DefaultTrait2 => sym::default_trait2,
            LangItem::DefaultTrait1 => sym::default_trait1,
            LangItem::ContractCheckEnsures => sym::contract_check_ensures,
            LangItem::Reborrow => sym::reborrow,
            LangItem::CoerceShared => sym::coerce_shared,
        }
    }
    /// Opposite of [`LangItem::name`]
    pub fn from_name(name: Symbol) -> Option<Self> {
        match name {
            sym::sized => Some(LangItem::Sized),
            sym::meta_sized => Some(LangItem::MetaSized),
            sym::pointee_sized => Some(LangItem::PointeeSized),
            sym::unsize => Some(LangItem::Unsize),
            sym::mem_align_const => Some(LangItem::AlignOf),
            sym::mem_size_const => Some(LangItem::SizeOf),
            sym::offset_of => Some(LangItem::OffsetOf),
            sym::structural_peq => Some(LangItem::StructuralPeq),
            sym::copy => Some(LangItem::Copy),
            sym::clone => Some(LangItem::Clone),
            sym::clone_fn => Some(LangItem::CloneFn),
            sym::use_cloned => Some(LangItem::UseCloned),
            sym::trivial_clone => Some(LangItem::TrivialClone),
            sym::sync => Some(LangItem::Sync),
            sym::discriminant_kind => Some(LangItem::DiscriminantKind),
            sym::discriminant_type => Some(LangItem::Discriminant),
            sym::pointee_trait => Some(LangItem::PointeeTrait),
            sym::metadata_type => Some(LangItem::Metadata),
            sym::dyn_metadata => Some(LangItem::DynMetadata),
            sym::freeze => Some(LangItem::Freeze),
            sym::unsafe_unpin => Some(LangItem::UnsafeUnpin),
            sym::fn_ptr_trait => Some(LangItem::FnPtrTrait),
            sym::fn_ptr_addr => Some(LangItem::FnPtrAddr),
            sym::drop => Some(LangItem::Drop),
            sym::destruct => Some(LangItem::Destruct),
            sym::async_drop => Some(LangItem::AsyncDrop),
            sym::async_drop_in_place => Some(LangItem::AsyncDropInPlace),
            sym::coerce_unsized => Some(LangItem::CoerceUnsized),
            sym::dispatch_from_dyn => Some(LangItem::DispatchFromDyn),
            sym::transmute_opts => Some(LangItem::TransmuteOpts),
            sym::transmute_trait => Some(LangItem::TransmuteTrait),
            sym::add => Some(LangItem::Add),
            sym::sub => Some(LangItem::Sub),
            sym::mul => Some(LangItem::Mul),
            sym::div => Some(LangItem::Div),
            sym::rem => Some(LangItem::Rem),
            sym::neg => Some(LangItem::Neg),
            sym::not => Some(LangItem::Not),
            sym::bitxor => Some(LangItem::BitXor),
            sym::bitand => Some(LangItem::BitAnd),
            sym::bitor => Some(LangItem::BitOr),
            sym::shl => Some(LangItem::Shl),
            sym::shr => Some(LangItem::Shr),
            sym::add_assign => Some(LangItem::AddAssign),
            sym::sub_assign => Some(LangItem::SubAssign),
            sym::mul_assign => Some(LangItem::MulAssign),
            sym::div_assign => Some(LangItem::DivAssign),
            sym::rem_assign => Some(LangItem::RemAssign),
            sym::bitxor_assign => Some(LangItem::BitXorAssign),
            sym::bitand_assign => Some(LangItem::BitAndAssign),
            sym::bitor_assign => Some(LangItem::BitOrAssign),
            sym::shl_assign => Some(LangItem::ShlAssign),
            sym::shr_assign => Some(LangItem::ShrAssign),
            sym::index => Some(LangItem::Index),
            sym::index_mut => Some(LangItem::IndexMut),
            sym::unsafe_cell => Some(LangItem::UnsafeCell),
            sym::unsafe_pinned => Some(LangItem::UnsafePinned),
            sym::va_list => Some(LangItem::VaList),
            sym::deref => Some(LangItem::Deref),
            sym::deref_mut => Some(LangItem::DerefMut),
            sym::deref_pure => Some(LangItem::DerefPure),
            sym::deref_target => Some(LangItem::DerefTarget),
            sym::receiver => Some(LangItem::Receiver),
            sym::receiver_target => Some(LangItem::ReceiverTarget),
            sym::legacy_receiver => Some(LangItem::LegacyReceiver),
            kw::Fn => Some(LangItem::Fn),
            sym::fn_mut => Some(LangItem::FnMut),
            sym::fn_once => Some(LangItem::FnOnce),
            sym::async_fn => Some(LangItem::AsyncFn),
            sym::async_fn_mut => Some(LangItem::AsyncFnMut),
            sym::async_fn_once => Some(LangItem::AsyncFnOnce),
            sym::async_fn_once_output => Some(LangItem::AsyncFnOnceOutput),
            sym::call_once_future => Some(LangItem::CallOnceFuture),
            sym::call_ref_future => Some(LangItem::CallRefFuture),
            sym::async_fn_kind_helper => Some(LangItem::AsyncFnKindHelper),
            sym::async_fn_kind_upvars => Some(LangItem::AsyncFnKindUpvars),
            sym::fn_once_output => Some(LangItem::FnOnceOutput),
            sym::iterator => Some(LangItem::Iterator),
            sym::fused_iterator => Some(LangItem::FusedIterator),
            sym::future_trait => Some(LangItem::Future),
            sym::future_output => Some(LangItem::FutureOutput),
            sym::async_iterator => Some(LangItem::AsyncIterator),
            sym::coroutine_state => Some(LangItem::CoroutineState),
            sym::coroutine => Some(LangItem::Coroutine),
            sym::coroutine_return => Some(LangItem::CoroutineReturn),
            sym::coroutine_yield => Some(LangItem::CoroutineYield),
            sym::coroutine_resume => Some(LangItem::CoroutineResume),
            sym::unpin => Some(LangItem::Unpin),
            sym::pin => Some(LangItem::Pin),
            sym::Ordering => Some(LangItem::OrderingEnum),
            sym::eq => Some(LangItem::PartialEq),
            sym::partial_ord => Some(LangItem::PartialOrd),
            sym::c_void => Some(LangItem::CVoid),
            sym::type_info => Some(LangItem::Type),
            sym::type_id => Some(LangItem::TypeId),
            sym::panic => Some(LangItem::Panic),
            sym::panic_nounwind => Some(LangItem::PanicNounwind),
            sym::panic_fmt => Some(LangItem::PanicFmt),
            sym::panic_display => Some(LangItem::PanicDisplay),
            sym::const_panic_fmt => Some(LangItem::ConstPanicFmt),
            sym::panic_bounds_check => Some(LangItem::PanicBoundsCheck),
            sym::panic_misaligned_pointer_dereference =>
                Some(LangItem::PanicMisalignedPointerDereference),
            sym::panic_info => Some(LangItem::PanicInfo),
            sym::panic_location => Some(LangItem::PanicLocation),
            sym::panic_impl => Some(LangItem::PanicImpl),
            sym::panic_cannot_unwind => Some(LangItem::PanicCannotUnwind),
            sym::panic_in_cleanup => Some(LangItem::PanicInCleanup),
            sym::panic_const_add_overflow => Some(LangItem::PanicAddOverflow),
            sym::panic_const_sub_overflow => Some(LangItem::PanicSubOverflow),
            sym::panic_const_mul_overflow => Some(LangItem::PanicMulOverflow),
            sym::panic_const_div_overflow => Some(LangItem::PanicDivOverflow),
            sym::panic_const_rem_overflow => Some(LangItem::PanicRemOverflow),
            sym::panic_const_neg_overflow => Some(LangItem::PanicNegOverflow),
            sym::panic_const_shr_overflow => Some(LangItem::PanicShrOverflow),
            sym::panic_const_shl_overflow => Some(LangItem::PanicShlOverflow),
            sym::panic_const_div_by_zero => Some(LangItem::PanicDivZero),
            sym::panic_const_rem_by_zero => Some(LangItem::PanicRemZero),
            sym::panic_const_coroutine_resumed =>
                Some(LangItem::PanicCoroutineResumed),
            sym::panic_const_async_fn_resumed =>
                Some(LangItem::PanicAsyncFnResumed),
            sym::panic_const_async_gen_fn_resumed =>
                Some(LangItem::PanicAsyncGenFnResumed),
            sym::panic_const_gen_fn_none => Some(LangItem::PanicGenFnNone),
            sym::panic_const_coroutine_resumed_panic =>
                Some(LangItem::PanicCoroutineResumedPanic),
            sym::panic_const_async_fn_resumed_panic =>
                Some(LangItem::PanicAsyncFnResumedPanic),
            sym::panic_const_async_gen_fn_resumed_panic =>
                Some(LangItem::PanicAsyncGenFnResumedPanic),
            sym::panic_const_gen_fn_none_panic =>
                Some(LangItem::PanicGenFnNonePanic),
            sym::panic_null_pointer_dereference =>
                Some(LangItem::PanicNullPointerDereference),
            sym::panic_invalid_enum_construction =>
                Some(LangItem::PanicInvalidEnumConstruction),
            sym::panic_const_coroutine_resumed_drop =>
                Some(LangItem::PanicCoroutineResumedDrop),
            sym::panic_const_async_fn_resumed_drop =>
                Some(LangItem::PanicAsyncFnResumedDrop),
            sym::panic_const_async_gen_fn_resumed_drop =>
                Some(LangItem::PanicAsyncGenFnResumedDrop),
            sym::panic_const_gen_fn_none_drop =>
                Some(LangItem::PanicGenFnNoneDrop),
            sym::begin_panic => Some(LangItem::BeginPanic),
            sym::format_argument => Some(LangItem::FormatArgument),
            sym::format_arguments => Some(LangItem::FormatArguments),
            sym::exchange_malloc => Some(LangItem::ExchangeMalloc),
            sym::drop_in_place => Some(LangItem::DropInPlace),
            sym::alloc_layout => Some(LangItem::AllocLayout),
            sym::start => Some(LangItem::Start),
            sym::eh_personality => Some(LangItem::EhPersonality),
            sym::eh_catch_typeinfo => Some(LangItem::EhCatchTypeinfo),
            sym::compiler_move => Some(LangItem::CompilerMove),
            sym::compiler_copy => Some(LangItem::CompilerCopy),
            sym::owned_box => Some(LangItem::OwnedBox),
            sym::global_alloc_ty => Some(LangItem::GlobalAlloc),
            sym::phantom_data => Some(LangItem::PhantomData),
            sym::manually_drop => Some(LangItem::ManuallyDrop),
            sym::bikeshed_guaranteed_no_drop =>
                Some(LangItem::BikeshedGuaranteedNoDrop),
            sym::maybe_uninit => Some(LangItem::MaybeUninit),
            sym::termination => Some(LangItem::Termination),
            sym::Try => Some(LangItem::Try),
            sym::tuple_trait => Some(LangItem::Tuple),
            sym::slice_len_fn => Some(LangItem::SliceLen),
            sym::from_residual => Some(LangItem::TryTraitFromResidual),
            sym::from_output => Some(LangItem::TryTraitFromOutput),
            sym::branch => Some(LangItem::TryTraitBranch),
            sym::from_yeet => Some(LangItem::TryTraitFromYeet),
            sym::into_try_type => Some(LangItem::ResidualIntoTryType),
            sym::coerce_pointee_validated =>
                Some(LangItem::CoercePointeeValidated),
            sym::const_param_ty => Some(LangItem::ConstParamTy),
            sym::Poll => Some(LangItem::Poll),
            sym::Ready => Some(LangItem::PollReady),
            sym::Pending => Some(LangItem::PollPending),
            sym::AsyncGenReady => Some(LangItem::AsyncGenReady),
            sym::AsyncGenPending => Some(LangItem::AsyncGenPending),
            sym::AsyncGenFinished => Some(LangItem::AsyncGenFinished),
            sym::ResumeTy => Some(LangItem::ResumeTy),
            sym::get_context => Some(LangItem::GetContext),
            sym::Context => Some(LangItem::Context),
            sym::poll => Some(LangItem::FuturePoll),
            sym::async_iterator_poll_next =>
                Some(LangItem::AsyncIteratorPollNext),
            sym::into_async_iter_into_iter =>
                Some(LangItem::IntoAsyncIterIntoIter),
            sym::Option => Some(LangItem::Option),
            sym::Some => Some(LangItem::OptionSome),
            sym::None => Some(LangItem::OptionNone),
            sym::Ok => Some(LangItem::ResultOk),
            sym::Err => Some(LangItem::ResultErr),
            sym::Continue => Some(LangItem::ControlFlowContinue),
            sym::Break => Some(LangItem::ControlFlowBreak),
            sym::into_future => Some(LangItem::IntoFutureIntoFuture),
            sym::into_iter => Some(LangItem::IntoIterIntoIter),
            sym::next => Some(LangItem::IteratorNext),
            sym::new_unchecked => Some(LangItem::PinNewUnchecked),
            sym::RangeFrom => Some(LangItem::RangeFrom),
            sym::RangeFull => Some(LangItem::RangeFull),
            sym::RangeInclusive => Some(LangItem::RangeInclusiveStruct),
            sym::range_inclusive_new => Some(LangItem::RangeInclusiveNew),
            sym::Range => Some(LangItem::Range),
            sym::RangeToInclusive => Some(LangItem::RangeToInclusive),
            sym::RangeTo => Some(LangItem::RangeTo),
            sym::RangeMax => Some(LangItem::RangeMax),
            sym::RangeMin => Some(LangItem::RangeMin),
            sym::RangeSub => Some(LangItem::RangeSub),
            sym::RangeFromCopy => Some(LangItem::RangeFromCopy),
            sym::RangeCopy => Some(LangItem::RangeCopy),
            sym::RangeInclusiveCopy => Some(LangItem::RangeInclusiveCopy),
            sym::RangeToInclusiveCopy => Some(LangItem::RangeToInclusiveCopy),
            sym::String => Some(LangItem::String),
            sym::CStr => Some(LangItem::CStr),
            sym::contract_build_check_ensures =>
                Some(LangItem::ContractBuildCheckEnsures),
            sym::contract_check_requires =>
                Some(LangItem::ContractCheckRequires),
            sym::default_trait4 => Some(LangItem::DefaultTrait4),
            sym::default_trait3 => Some(LangItem::DefaultTrait3),
            sym::default_trait2 => Some(LangItem::DefaultTrait2),
            sym::default_trait1 => Some(LangItem::DefaultTrait1),
            sym::contract_check_ensures =>
                Some(LangItem::ContractCheckEnsures),
            sym::reborrow => Some(LangItem::Reborrow),
            sym::coerce_shared => Some(LangItem::CoerceShared),
            _ => None,
        }
    }
    /// Returns the name of the `LangItem` enum variant.
    pub fn variant_name(self) -> &'static str {
        match self {
            LangItem::Sized => "Sized",
            LangItem::MetaSized => "MetaSized",
            LangItem::PointeeSized => "PointeeSized",
            LangItem::Unsize => "Unsize",
            LangItem::AlignOf => "AlignOf",
            LangItem::SizeOf => "SizeOf",
            LangItem::OffsetOf => "OffsetOf",
            LangItem::StructuralPeq => "StructuralPeq",
            LangItem::Copy => "Copy",
            LangItem::Clone => "Clone",
            LangItem::CloneFn => "CloneFn",
            LangItem::UseCloned => "UseCloned",
            LangItem::TrivialClone => "TrivialClone",
            LangItem::Sync => "Sync",
            LangItem::DiscriminantKind => "DiscriminantKind",
            LangItem::Discriminant => "Discriminant",
            LangItem::PointeeTrait => "PointeeTrait",
            LangItem::Metadata => "Metadata",
            LangItem::DynMetadata => "DynMetadata",
            LangItem::Freeze => "Freeze",
            LangItem::UnsafeUnpin => "UnsafeUnpin",
            LangItem::FnPtrTrait => "FnPtrTrait",
            LangItem::FnPtrAddr => "FnPtrAddr",
            LangItem::Drop => "Drop",
            LangItem::Destruct => "Destruct",
            LangItem::AsyncDrop => "AsyncDrop",
            LangItem::AsyncDropInPlace => "AsyncDropInPlace",
            LangItem::CoerceUnsized => "CoerceUnsized",
            LangItem::DispatchFromDyn => "DispatchFromDyn",
            LangItem::TransmuteOpts => "TransmuteOpts",
            LangItem::TransmuteTrait => "TransmuteTrait",
            LangItem::Add => "Add",
            LangItem::Sub => "Sub",
            LangItem::Mul => "Mul",
            LangItem::Div => "Div",
            LangItem::Rem => "Rem",
            LangItem::Neg => "Neg",
            LangItem::Not => "Not",
            LangItem::BitXor => "BitXor",
            LangItem::BitAnd => "BitAnd",
            LangItem::BitOr => "BitOr",
            LangItem::Shl => "Shl",
            LangItem::Shr => "Shr",
            LangItem::AddAssign => "AddAssign",
            LangItem::SubAssign => "SubAssign",
            LangItem::MulAssign => "MulAssign",
            LangItem::DivAssign => "DivAssign",
            LangItem::RemAssign => "RemAssign",
            LangItem::BitXorAssign => "BitXorAssign",
            LangItem::BitAndAssign => "BitAndAssign",
            LangItem::BitOrAssign => "BitOrAssign",
            LangItem::ShlAssign => "ShlAssign",
            LangItem::ShrAssign => "ShrAssign",
            LangItem::Index => "Index",
            LangItem::IndexMut => "IndexMut",
            LangItem::UnsafeCell => "UnsafeCell",
            LangItem::UnsafePinned => "UnsafePinned",
            LangItem::VaList => "VaList",
            LangItem::Deref => "Deref",
            LangItem::DerefMut => "DerefMut",
            LangItem::DerefPure => "DerefPure",
            LangItem::DerefTarget => "DerefTarget",
            LangItem::Receiver => "Receiver",
            LangItem::ReceiverTarget => "ReceiverTarget",
            LangItem::LegacyReceiver => "LegacyReceiver",
            LangItem::Fn => "Fn",
            LangItem::FnMut => "FnMut",
            LangItem::FnOnce => "FnOnce",
            LangItem::AsyncFn => "AsyncFn",
            LangItem::AsyncFnMut => "AsyncFnMut",
            LangItem::AsyncFnOnce => "AsyncFnOnce",
            LangItem::AsyncFnOnceOutput => "AsyncFnOnceOutput",
            LangItem::CallOnceFuture => "CallOnceFuture",
            LangItem::CallRefFuture => "CallRefFuture",
            LangItem::AsyncFnKindHelper => "AsyncFnKindHelper",
            LangItem::AsyncFnKindUpvars => "AsyncFnKindUpvars",
            LangItem::FnOnceOutput => "FnOnceOutput",
            LangItem::Iterator => "Iterator",
            LangItem::FusedIterator => "FusedIterator",
            LangItem::Future => "Future",
            LangItem::FutureOutput => "FutureOutput",
            LangItem::AsyncIterator => "AsyncIterator",
            LangItem::CoroutineState => "CoroutineState",
            LangItem::Coroutine => "Coroutine",
            LangItem::CoroutineReturn => "CoroutineReturn",
            LangItem::CoroutineYield => "CoroutineYield",
            LangItem::CoroutineResume => "CoroutineResume",
            LangItem::Unpin => "Unpin",
            LangItem::Pin => "Pin",
            LangItem::OrderingEnum => "OrderingEnum",
            LangItem::PartialEq => "PartialEq",
            LangItem::PartialOrd => "PartialOrd",
            LangItem::CVoid => "CVoid",
            LangItem::Type => "Type",
            LangItem::TypeId => "TypeId",
            LangItem::Panic => "Panic",
            LangItem::PanicNounwind => "PanicNounwind",
            LangItem::PanicFmt => "PanicFmt",
            LangItem::PanicDisplay => "PanicDisplay",
            LangItem::ConstPanicFmt => "ConstPanicFmt",
            LangItem::PanicBoundsCheck => "PanicBoundsCheck",
            LangItem::PanicMisalignedPointerDereference =>
                "PanicMisalignedPointerDereference",
            LangItem::PanicInfo => "PanicInfo",
            LangItem::PanicLocation => "PanicLocation",
            LangItem::PanicImpl => "PanicImpl",
            LangItem::PanicCannotUnwind => "PanicCannotUnwind",
            LangItem::PanicInCleanup => "PanicInCleanup",
            LangItem::PanicAddOverflow => "PanicAddOverflow",
            LangItem::PanicSubOverflow => "PanicSubOverflow",
            LangItem::PanicMulOverflow => "PanicMulOverflow",
            LangItem::PanicDivOverflow => "PanicDivOverflow",
            LangItem::PanicRemOverflow => "PanicRemOverflow",
            LangItem::PanicNegOverflow => "PanicNegOverflow",
            LangItem::PanicShrOverflow => "PanicShrOverflow",
            LangItem::PanicShlOverflow => "PanicShlOverflow",
            LangItem::PanicDivZero => "PanicDivZero",
            LangItem::PanicRemZero => "PanicRemZero",
            LangItem::PanicCoroutineResumed => "PanicCoroutineResumed",
            LangItem::PanicAsyncFnResumed => "PanicAsyncFnResumed",
            LangItem::PanicAsyncGenFnResumed => "PanicAsyncGenFnResumed",
            LangItem::PanicGenFnNone => "PanicGenFnNone",
            LangItem::PanicCoroutineResumedPanic =>
                "PanicCoroutineResumedPanic",
            LangItem::PanicAsyncFnResumedPanic => "PanicAsyncFnResumedPanic",
            LangItem::PanicAsyncGenFnResumedPanic =>
                "PanicAsyncGenFnResumedPanic",
            LangItem::PanicGenFnNonePanic => "PanicGenFnNonePanic",
            LangItem::PanicNullPointerDereference =>
                "PanicNullPointerDereference",
            LangItem::PanicInvalidEnumConstruction =>
                "PanicInvalidEnumConstruction",
            LangItem::PanicCoroutineResumedDrop =>
                "PanicCoroutineResumedDrop",
            LangItem::PanicAsyncFnResumedDrop => "PanicAsyncFnResumedDrop",
            LangItem::PanicAsyncGenFnResumedDrop =>
                "PanicAsyncGenFnResumedDrop",
            LangItem::PanicGenFnNoneDrop => "PanicGenFnNoneDrop",
            LangItem::BeginPanic => "BeginPanic",
            LangItem::FormatArgument => "FormatArgument",
            LangItem::FormatArguments => "FormatArguments",
            LangItem::ExchangeMalloc => "ExchangeMalloc",
            LangItem::DropInPlace => "DropInPlace",
            LangItem::AllocLayout => "AllocLayout",
            LangItem::Start => "Start",
            LangItem::EhPersonality => "EhPersonality",
            LangItem::EhCatchTypeinfo => "EhCatchTypeinfo",
            LangItem::CompilerMove => "CompilerMove",
            LangItem::CompilerCopy => "CompilerCopy",
            LangItem::OwnedBox => "OwnedBox",
            LangItem::GlobalAlloc => "GlobalAlloc",
            LangItem::PhantomData => "PhantomData",
            LangItem::ManuallyDrop => "ManuallyDrop",
            LangItem::BikeshedGuaranteedNoDrop => "BikeshedGuaranteedNoDrop",
            LangItem::MaybeUninit => "MaybeUninit",
            LangItem::Termination => "Termination",
            LangItem::Try => "Try",
            LangItem::Tuple => "Tuple",
            LangItem::SliceLen => "SliceLen",
            LangItem::TryTraitFromResidual => "TryTraitFromResidual",
            LangItem::TryTraitFromOutput => "TryTraitFromOutput",
            LangItem::TryTraitBranch => "TryTraitBranch",
            LangItem::TryTraitFromYeet => "TryTraitFromYeet",
            LangItem::ResidualIntoTryType => "ResidualIntoTryType",
            LangItem::CoercePointeeValidated => "CoercePointeeValidated",
            LangItem::ConstParamTy => "ConstParamTy",
            LangItem::Poll => "Poll",
            LangItem::PollReady => "PollReady",
            LangItem::PollPending => "PollPending",
            LangItem::AsyncGenReady => "AsyncGenReady",
            LangItem::AsyncGenPending => "AsyncGenPending",
            LangItem::AsyncGenFinished => "AsyncGenFinished",
            LangItem::ResumeTy => "ResumeTy",
            LangItem::GetContext => "GetContext",
            LangItem::Context => "Context",
            LangItem::FuturePoll => "FuturePoll",
            LangItem::AsyncIteratorPollNext => "AsyncIteratorPollNext",
            LangItem::IntoAsyncIterIntoIter => "IntoAsyncIterIntoIter",
            LangItem::Option => "Option",
            LangItem::OptionSome => "OptionSome",
            LangItem::OptionNone => "OptionNone",
            LangItem::ResultOk => "ResultOk",
            LangItem::ResultErr => "ResultErr",
            LangItem::ControlFlowContinue => "ControlFlowContinue",
            LangItem::ControlFlowBreak => "ControlFlowBreak",
            LangItem::IntoFutureIntoFuture => "IntoFutureIntoFuture",
            LangItem::IntoIterIntoIter => "IntoIterIntoIter",
            LangItem::IteratorNext => "IteratorNext",
            LangItem::PinNewUnchecked => "PinNewUnchecked",
            LangItem::RangeFrom => "RangeFrom",
            LangItem::RangeFull => "RangeFull",
            LangItem::RangeInclusiveStruct => "RangeInclusiveStruct",
            LangItem::RangeInclusiveNew => "RangeInclusiveNew",
            LangItem::Range => "Range",
            LangItem::RangeToInclusive => "RangeToInclusive",
            LangItem::RangeTo => "RangeTo",
            LangItem::RangeMax => "RangeMax",
            LangItem::RangeMin => "RangeMin",
            LangItem::RangeSub => "RangeSub",
            LangItem::RangeFromCopy => "RangeFromCopy",
            LangItem::RangeCopy => "RangeCopy",
            LangItem::RangeInclusiveCopy => "RangeInclusiveCopy",
            LangItem::RangeToInclusiveCopy => "RangeToInclusiveCopy",
            LangItem::String => "String",
            LangItem::CStr => "CStr",
            LangItem::ContractBuildCheckEnsures =>
                "ContractBuildCheckEnsures",
            LangItem::ContractCheckRequires => "ContractCheckRequires",
            LangItem::DefaultTrait4 => "DefaultTrait4",
            LangItem::DefaultTrait3 => "DefaultTrait3",
            LangItem::DefaultTrait2 => "DefaultTrait2",
            LangItem::DefaultTrait1 => "DefaultTrait1",
            LangItem::ContractCheckEnsures => "ContractCheckEnsures",
            LangItem::Reborrow => "Reborrow",
            LangItem::CoerceShared => "CoerceShared",
        }
    }
    pub fn target(self) -> Target {
        match self {
            LangItem::Sized => Target::Trait,
            LangItem::MetaSized => Target::Trait,
            LangItem::PointeeSized => Target::Trait,
            LangItem::Unsize => Target::Trait,
            LangItem::AlignOf => Target::AssocConst,
            LangItem::SizeOf => Target::AssocConst,
            LangItem::OffsetOf => Target::Fn,
            LangItem::StructuralPeq => Target::Trait,
            LangItem::Copy => Target::Trait,
            LangItem::Clone => Target::Trait,
            LangItem::CloneFn =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::UseCloned => Target::Trait,
            LangItem::TrivialClone => Target::Trait,
            LangItem::Sync => Target::Trait,
            LangItem::DiscriminantKind => Target::Trait,
            LangItem::Discriminant => Target::AssocTy,
            LangItem::PointeeTrait => Target::Trait,
            LangItem::Metadata => Target::AssocTy,
            LangItem::DynMetadata => Target::Struct,
            LangItem::Freeze => Target::Trait,
            LangItem::UnsafeUnpin => Target::Trait,
            LangItem::FnPtrTrait => Target::Trait,
            LangItem::FnPtrAddr =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::Drop => Target::Trait,
            LangItem::Destruct => Target::Trait,
            LangItem::AsyncDrop => Target::Trait,
            LangItem::AsyncDropInPlace => Target::Fn,
            LangItem::CoerceUnsized => Target::Trait,
            LangItem::DispatchFromDyn => Target::Trait,
            LangItem::TransmuteOpts => Target::Struct,
            LangItem::TransmuteTrait => Target::Trait,
            LangItem::Add => Target::Trait,
            LangItem::Sub => Target::Trait,
            LangItem::Mul => Target::Trait,
            LangItem::Div => Target::Trait,
            LangItem::Rem => Target::Trait,
            LangItem::Neg => Target::Trait,
            LangItem::Not => Target::Trait,
            LangItem::BitXor => Target::Trait,
            LangItem::BitAnd => Target::Trait,
            LangItem::BitOr => Target::Trait,
            LangItem::Shl => Target::Trait,
            LangItem::Shr => Target::Trait,
            LangItem::AddAssign => Target::Trait,
            LangItem::SubAssign => Target::Trait,
            LangItem::MulAssign => Target::Trait,
            LangItem::DivAssign => Target::Trait,
            LangItem::RemAssign => Target::Trait,
            LangItem::BitXorAssign => Target::Trait,
            LangItem::BitAndAssign => Target::Trait,
            LangItem::BitOrAssign => Target::Trait,
            LangItem::ShlAssign => Target::Trait,
            LangItem::ShrAssign => Target::Trait,
            LangItem::Index => Target::Trait,
            LangItem::IndexMut => Target::Trait,
            LangItem::UnsafeCell => Target::Struct,
            LangItem::UnsafePinned => Target::Struct,
            LangItem::VaList => Target::Struct,
            LangItem::Deref => Target::Trait,
            LangItem::DerefMut => Target::Trait,
            LangItem::DerefPure => Target::Trait,
            LangItem::DerefTarget => Target::AssocTy,
            LangItem::Receiver => Target::Trait,
            LangItem::ReceiverTarget => Target::AssocTy,
            LangItem::LegacyReceiver => Target::Trait,
            LangItem::Fn => Target::Trait,
            LangItem::FnMut => Target::Trait,
            LangItem::FnOnce => Target::Trait,
            LangItem::AsyncFn => Target::Trait,
            LangItem::AsyncFnMut => Target::Trait,
            LangItem::AsyncFnOnce => Target::Trait,
            LangItem::AsyncFnOnceOutput => Target::AssocTy,
            LangItem::CallOnceFuture => Target::AssocTy,
            LangItem::CallRefFuture => Target::AssocTy,
            LangItem::AsyncFnKindHelper => Target::Trait,
            LangItem::AsyncFnKindUpvars => Target::AssocTy,
            LangItem::FnOnceOutput => Target::AssocTy,
            LangItem::Iterator => Target::Trait,
            LangItem::FusedIterator => Target::Trait,
            LangItem::Future => Target::Trait,
            LangItem::FutureOutput => Target::AssocTy,
            LangItem::AsyncIterator => Target::Trait,
            LangItem::CoroutineState => Target::Enum,
            LangItem::Coroutine => Target::Trait,
            LangItem::CoroutineReturn => Target::AssocTy,
            LangItem::CoroutineYield => Target::AssocTy,
            LangItem::CoroutineResume =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::Unpin => Target::Trait,
            LangItem::Pin => Target::Struct,
            LangItem::OrderingEnum => Target::Enum,
            LangItem::PartialEq => Target::Trait,
            LangItem::PartialOrd => Target::Trait,
            LangItem::CVoid => Target::Enum,
            LangItem::Type => Target::Struct,
            LangItem::TypeId => Target::Struct,
            LangItem::Panic => Target::Fn,
            LangItem::PanicNounwind => Target::Fn,
            LangItem::PanicFmt => Target::Fn,
            LangItem::PanicDisplay => Target::Fn,
            LangItem::ConstPanicFmt => Target::Fn,
            LangItem::PanicBoundsCheck => Target::Fn,
            LangItem::PanicMisalignedPointerDereference => Target::Fn,
            LangItem::PanicInfo => Target::Struct,
            LangItem::PanicLocation => Target::Struct,
            LangItem::PanicImpl => Target::Fn,
            LangItem::PanicCannotUnwind => Target::Fn,
            LangItem::PanicInCleanup => Target::Fn,
            LangItem::PanicAddOverflow => Target::Fn,
            LangItem::PanicSubOverflow => Target::Fn,
            LangItem::PanicMulOverflow => Target::Fn,
            LangItem::PanicDivOverflow => Target::Fn,
            LangItem::PanicRemOverflow => Target::Fn,
            LangItem::PanicNegOverflow => Target::Fn,
            LangItem::PanicShrOverflow => Target::Fn,
            LangItem::PanicShlOverflow => Target::Fn,
            LangItem::PanicDivZero => Target::Fn,
            LangItem::PanicRemZero => Target::Fn,
            LangItem::PanicCoroutineResumed => Target::Fn,
            LangItem::PanicAsyncFnResumed => Target::Fn,
            LangItem::PanicAsyncGenFnResumed => Target::Fn,
            LangItem::PanicGenFnNone => Target::Fn,
            LangItem::PanicCoroutineResumedPanic => Target::Fn,
            LangItem::PanicAsyncFnResumedPanic => Target::Fn,
            LangItem::PanicAsyncGenFnResumedPanic => Target::Fn,
            LangItem::PanicGenFnNonePanic => Target::Fn,
            LangItem::PanicNullPointerDereference => Target::Fn,
            LangItem::PanicInvalidEnumConstruction => Target::Fn,
            LangItem::PanicCoroutineResumedDrop => Target::Fn,
            LangItem::PanicAsyncFnResumedDrop => Target::Fn,
            LangItem::PanicAsyncGenFnResumedDrop => Target::Fn,
            LangItem::PanicGenFnNoneDrop => Target::Fn,
            LangItem::BeginPanic => Target::Fn,
            LangItem::FormatArgument => Target::Struct,
            LangItem::FormatArguments => Target::Struct,
            LangItem::ExchangeMalloc => Target::Fn,
            LangItem::DropInPlace => Target::Fn,
            LangItem::AllocLayout => Target::Struct,
            LangItem::Start => Target::Fn,
            LangItem::EhPersonality => Target::Fn,
            LangItem::EhCatchTypeinfo => Target::Static,
            LangItem::CompilerMove => Target::Fn,
            LangItem::CompilerCopy => Target::Fn,
            LangItem::OwnedBox => Target::Struct,
            LangItem::GlobalAlloc => Target::Struct,
            LangItem::PhantomData => Target::Struct,
            LangItem::ManuallyDrop => Target::Struct,
            LangItem::BikeshedGuaranteedNoDrop => Target::Trait,
            LangItem::MaybeUninit => Target::Union,
            LangItem::Termination => Target::Trait,
            LangItem::Try => Target::Trait,
            LangItem::Tuple => Target::Trait,
            LangItem::SliceLen => Target::Method(MethodKind::Inherent),
            LangItem::TryTraitFromResidual =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::TryTraitFromOutput =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::TryTraitBranch =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::TryTraitFromYeet => Target::Fn,
            LangItem::ResidualIntoTryType => Target::Fn,
            LangItem::CoercePointeeValidated => Target::Trait,
            LangItem::ConstParamTy => Target::Trait,
            LangItem::Poll => Target::Enum,
            LangItem::PollReady => Target::Variant,
            LangItem::PollPending => Target::Variant,
            LangItem::AsyncGenReady => Target::Method(MethodKind::Inherent),
            LangItem::AsyncGenPending => Target::AssocConst,
            LangItem::AsyncGenFinished => Target::AssocConst,
            LangItem::ResumeTy => Target::Struct,
            LangItem::GetContext => Target::Fn,
            LangItem::Context => Target::Struct,
            LangItem::FuturePoll =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::AsyncIteratorPollNext =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::IntoAsyncIterIntoIter =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::Option => Target::Enum,
            LangItem::OptionSome => Target::Variant,
            LangItem::OptionNone => Target::Variant,
            LangItem::ResultOk => Target::Variant,
            LangItem::ResultErr => Target::Variant,
            LangItem::ControlFlowContinue => Target::Variant,
            LangItem::ControlFlowBreak => Target::Variant,
            LangItem::IntoFutureIntoFuture =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::IntoIterIntoIter =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::IteratorNext =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::PinNewUnchecked => Target::Method(MethodKind::Inherent),
            LangItem::RangeFrom => Target::Struct,
            LangItem::RangeFull => Target::Struct,
            LangItem::RangeInclusiveStruct => Target::Struct,
            LangItem::RangeInclusiveNew =>
                Target::Method(MethodKind::Inherent),
            LangItem::Range => Target::Struct,
            LangItem::RangeToInclusive => Target::Struct,
            LangItem::RangeTo => Target::Struct,
            LangItem::RangeMax => Target::AssocConst,
            LangItem::RangeMin => Target::AssocConst,
            LangItem::RangeSub =>
                Target::Method(MethodKind::Trait { body: false }),
            LangItem::RangeFromCopy => Target::Struct,
            LangItem::RangeCopy => Target::Struct,
            LangItem::RangeInclusiveCopy => Target::Struct,
            LangItem::RangeToInclusiveCopy => Target::Struct,
            LangItem::String => Target::Struct,
            LangItem::CStr => Target::Struct,
            LangItem::ContractBuildCheckEnsures => Target::Fn,
            LangItem::ContractCheckRequires => Target::Fn,
            LangItem::DefaultTrait4 => Target::Trait,
            LangItem::DefaultTrait3 => Target::Trait,
            LangItem::DefaultTrait2 => Target::Trait,
            LangItem::DefaultTrait1 => Target::Trait,
            LangItem::ContractCheckEnsures => Target::Fn,
            LangItem::Reborrow => Target::Trait,
            LangItem::CoerceShared => Target::Trait,
        }
    }
    pub fn required_generics(&self) -> GenericRequirement {
        match self {
            LangItem::Sized => GenericRequirement::Exact(0),
            LangItem::MetaSized => GenericRequirement::Exact(0),
            LangItem::PointeeSized => GenericRequirement::Exact(0),
            LangItem::Unsize => GenericRequirement::Minimum(1),
            LangItem::AlignOf => GenericRequirement::Exact(0),
            LangItem::SizeOf => GenericRequirement::Exact(0),
            LangItem::OffsetOf => GenericRequirement::Exact(1),
            LangItem::StructuralPeq => GenericRequirement::None,
            LangItem::Copy => GenericRequirement::Exact(0),
            LangItem::Clone => GenericRequirement::None,
            LangItem::CloneFn => GenericRequirement::None,
            LangItem::UseCloned => GenericRequirement::None,
            LangItem::TrivialClone => GenericRequirement::None,
            LangItem::Sync => GenericRequirement::Exact(0),
            LangItem::DiscriminantKind => GenericRequirement::None,
            LangItem::Discriminant => GenericRequirement::None,
            LangItem::PointeeTrait => GenericRequirement::None,
            LangItem::Metadata => GenericRequirement::None,
            LangItem::DynMetadata => GenericRequirement::None,
            LangItem::Freeze => GenericRequirement::Exact(0),
            LangItem::UnsafeUnpin => GenericRequirement::Exact(0),
            LangItem::FnPtrTrait => GenericRequirement::Exact(0),
            LangItem::FnPtrAddr => GenericRequirement::None,
            LangItem::Drop => GenericRequirement::None,
            LangItem::Destruct => GenericRequirement::None,
            LangItem::AsyncDrop => GenericRequirement::None,
            LangItem::AsyncDropInPlace => GenericRequirement::Exact(1),
            LangItem::CoerceUnsized => GenericRequirement::Minimum(1),
            LangItem::DispatchFromDyn => GenericRequirement::Minimum(1),
            LangItem::TransmuteOpts => GenericRequirement::Exact(0),
            LangItem::TransmuteTrait => GenericRequirement::Exact(2),
            LangItem::Add => GenericRequirement::Exact(1),
            LangItem::Sub => GenericRequirement::Exact(1),
            LangItem::Mul => GenericRequirement::Exact(1),
            LangItem::Div => GenericRequirement::Exact(1),
            LangItem::Rem => GenericRequirement::Exact(1),
            LangItem::Neg => GenericRequirement::Exact(0),
            LangItem::Not => GenericRequirement::Exact(0),
            LangItem::BitXor => GenericRequirement::Exact(1),
            LangItem::BitAnd => GenericRequirement::Exact(1),
            LangItem::BitOr => GenericRequirement::Exact(1),
            LangItem::Shl => GenericRequirement::Exact(1),
            LangItem::Shr => GenericRequirement::Exact(1),
            LangItem::AddAssign => GenericRequirement::Exact(1),
            LangItem::SubAssign => GenericRequirement::Exact(1),
            LangItem::MulAssign => GenericRequirement::Exact(1),
            LangItem::DivAssign => GenericRequirement::Exact(1),
            LangItem::RemAssign => GenericRequirement::Exact(1),
            LangItem::BitXorAssign => GenericRequirement::Exact(1),
            LangItem::BitAndAssign => GenericRequirement::Exact(1),
            LangItem::BitOrAssign => GenericRequirement::Exact(1),
            LangItem::ShlAssign => GenericRequirement::Exact(1),
            LangItem::ShrAssign => GenericRequirement::Exact(1),
            LangItem::Index => GenericRequirement::Exact(1),
            LangItem::IndexMut => GenericRequirement::Exact(1),
            LangItem::UnsafeCell => GenericRequirement::None,
            LangItem::UnsafePinned => GenericRequirement::None,
            LangItem::VaList => GenericRequirement::None,
            LangItem::Deref => GenericRequirement::Exact(0),
            LangItem::DerefMut => GenericRequirement::Exact(0),
            LangItem::DerefPure => GenericRequirement::Exact(0),
            LangItem::DerefTarget => GenericRequirement::None,
            LangItem::Receiver => GenericRequirement::None,
            LangItem::ReceiverTarget => GenericRequirement::None,
            LangItem::LegacyReceiver => GenericRequirement::None,
            LangItem::Fn => GenericRequirement::Exact(1),
            LangItem::FnMut => GenericRequirement::Exact(1),
            LangItem::FnOnce => GenericRequirement::Exact(1),
            LangItem::AsyncFn => GenericRequirement::Exact(1),
            LangItem::AsyncFnMut => GenericRequirement::Exact(1),
            LangItem::AsyncFnOnce => GenericRequirement::Exact(1),
            LangItem::AsyncFnOnceOutput => GenericRequirement::Exact(1),
            LangItem::CallOnceFuture => GenericRequirement::Exact(1),
            LangItem::CallRefFuture => GenericRequirement::Exact(2),
            LangItem::AsyncFnKindHelper => GenericRequirement::Exact(1),
            LangItem::AsyncFnKindUpvars => GenericRequirement::Exact(5),
            LangItem::FnOnceOutput => GenericRequirement::None,
            LangItem::Iterator => GenericRequirement::Exact(0),
            LangItem::FusedIterator => GenericRequirement::Exact(0),
            LangItem::Future => GenericRequirement::Exact(0),
            LangItem::FutureOutput => GenericRequirement::Exact(0),
            LangItem::AsyncIterator => GenericRequirement::Exact(0),
            LangItem::CoroutineState => GenericRequirement::None,
            LangItem::Coroutine => GenericRequirement::Exact(1),
            LangItem::CoroutineReturn => GenericRequirement::Exact(1),
            LangItem::CoroutineYield => GenericRequirement::Exact(1),
            LangItem::CoroutineResume => GenericRequirement::None,
            LangItem::Unpin => GenericRequirement::None,
            LangItem::Pin => GenericRequirement::None,
            LangItem::OrderingEnum => GenericRequirement::Exact(0),
            LangItem::PartialEq => GenericRequirement::Exact(1),
            LangItem::PartialOrd => GenericRequirement::Exact(1),
            LangItem::CVoid => GenericRequirement::None,
            LangItem::Type => GenericRequirement::None,
            LangItem::TypeId => GenericRequirement::None,
            LangItem::Panic => GenericRequirement::Exact(0),
            LangItem::PanicNounwind => GenericRequirement::Exact(0),
            LangItem::PanicFmt => GenericRequirement::None,
            LangItem::PanicDisplay => GenericRequirement::None,
            LangItem::ConstPanicFmt => GenericRequirement::None,
            LangItem::PanicBoundsCheck => GenericRequirement::Exact(0),
            LangItem::PanicMisalignedPointerDereference =>
                GenericRequirement::Exact(0),
            LangItem::PanicInfo => GenericRequirement::None,
            LangItem::PanicLocation => GenericRequirement::None,
            LangItem::PanicImpl => GenericRequirement::None,
            LangItem::PanicCannotUnwind => GenericRequirement::Exact(0),
            LangItem::PanicInCleanup => GenericRequirement::Exact(0),
            LangItem::PanicAddOverflow => GenericRequirement::None,
            LangItem::PanicSubOverflow => GenericRequirement::None,
            LangItem::PanicMulOverflow => GenericRequirement::None,
            LangItem::PanicDivOverflow => GenericRequirement::None,
            LangItem::PanicRemOverflow => GenericRequirement::None,
            LangItem::PanicNegOverflow => GenericRequirement::None,
            LangItem::PanicShrOverflow => GenericRequirement::None,
            LangItem::PanicShlOverflow => GenericRequirement::None,
            LangItem::PanicDivZero => GenericRequirement::None,
            LangItem::PanicRemZero => GenericRequirement::None,
            LangItem::PanicCoroutineResumed => GenericRequirement::None,
            LangItem::PanicAsyncFnResumed => GenericRequirement::None,
            LangItem::PanicAsyncGenFnResumed => GenericRequirement::None,
            LangItem::PanicGenFnNone => GenericRequirement::None,
            LangItem::PanicCoroutineResumedPanic => GenericRequirement::None,
            LangItem::PanicAsyncFnResumedPanic => GenericRequirement::None,
            LangItem::PanicAsyncGenFnResumedPanic => GenericRequirement::None,
            LangItem::PanicGenFnNonePanic => GenericRequirement::None,
            LangItem::PanicNullPointerDereference => GenericRequirement::None,
            LangItem::PanicInvalidEnumConstruction =>
                GenericRequirement::None,
            LangItem::PanicCoroutineResumedDrop => GenericRequirement::None,
            LangItem::PanicAsyncFnResumedDrop => GenericRequirement::None,
            LangItem::PanicAsyncGenFnResumedDrop => GenericRequirement::None,
            LangItem::PanicGenFnNoneDrop => GenericRequirement::None,
            LangItem::BeginPanic => GenericRequirement::None,
            LangItem::FormatArgument => GenericRequirement::None,
            LangItem::FormatArguments => GenericRequirement::None,
            LangItem::ExchangeMalloc => GenericRequirement::None,
            LangItem::DropInPlace => GenericRequirement::Minimum(1),
            LangItem::AllocLayout => GenericRequirement::None,
            LangItem::Start => GenericRequirement::Exact(1),
            LangItem::EhPersonality => GenericRequirement::None,
            LangItem::EhCatchTypeinfo => GenericRequirement::None,
            LangItem::CompilerMove => GenericRequirement::Exact(2),
            LangItem::CompilerCopy => GenericRequirement::Exact(2),
            LangItem::OwnedBox => GenericRequirement::Minimum(1),
            LangItem::GlobalAlloc => GenericRequirement::None,
            LangItem::PhantomData => GenericRequirement::Exact(1),
            LangItem::ManuallyDrop => GenericRequirement::None,
            LangItem::BikeshedGuaranteedNoDrop =>
                GenericRequirement::Exact(0),
            LangItem::MaybeUninit => GenericRequirement::None,
            LangItem::Termination => GenericRequirement::None,
            LangItem::Try => GenericRequirement::None,
            LangItem::Tuple => GenericRequirement::Exact(0),
            LangItem::SliceLen => GenericRequirement::None,
            LangItem::TryTraitFromResidual => GenericRequirement::None,
            LangItem::TryTraitFromOutput => GenericRequirement::None,
            LangItem::TryTraitBranch => GenericRequirement::None,
            LangItem::TryTraitFromYeet => GenericRequirement::None,
            LangItem::ResidualIntoTryType => GenericRequirement::None,
            LangItem::CoercePointeeValidated => GenericRequirement::Exact(0),
            LangItem::ConstParamTy => GenericRequirement::Exact(0),
            LangItem::Poll => GenericRequirement::None,
            LangItem::PollReady => GenericRequirement::None,
            LangItem::PollPending => GenericRequirement::None,
            LangItem::AsyncGenReady => GenericRequirement::Exact(1),
            LangItem::AsyncGenPending => GenericRequirement::Exact(1),
            LangItem::AsyncGenFinished => GenericRequirement::Exact(1),
            LangItem::ResumeTy => GenericRequirement::None,
            LangItem::GetContext => GenericRequirement::None,
            LangItem::Context => GenericRequirement::None,
            LangItem::FuturePoll => GenericRequirement::None,
            LangItem::AsyncIteratorPollNext => GenericRequirement::Exact(0),
            LangItem::IntoAsyncIterIntoIter => GenericRequirement::Exact(0),
            LangItem::Option => GenericRequirement::None,
            LangItem::OptionSome => GenericRequirement::None,
            LangItem::OptionNone => GenericRequirement::None,
            LangItem::ResultOk => GenericRequirement::None,
            LangItem::ResultErr => GenericRequirement::None,
            LangItem::ControlFlowContinue => GenericRequirement::None,
            LangItem::ControlFlowBreak => GenericRequirement::None,
            LangItem::IntoFutureIntoFuture => GenericRequirement::None,
            LangItem::IntoIterIntoIter => GenericRequirement::None,
            LangItem::IteratorNext => GenericRequirement::None,
            LangItem::PinNewUnchecked => GenericRequirement::None,
            LangItem::RangeFrom => GenericRequirement::None,
            LangItem::RangeFull => GenericRequirement::None,
            LangItem::RangeInclusiveStruct => GenericRequirement::None,
            LangItem::RangeInclusiveNew => GenericRequirement::None,
            LangItem::Range => GenericRequirement::None,
            LangItem::RangeToInclusive => GenericRequirement::None,
            LangItem::RangeTo => GenericRequirement::None,
            LangItem::RangeMax => GenericRequirement::Exact(0),
            LangItem::RangeMin => GenericRequirement::Exact(0),
            LangItem::RangeSub => GenericRequirement::Exact(0),
            LangItem::RangeFromCopy => GenericRequirement::None,
            LangItem::RangeCopy => GenericRequirement::None,
            LangItem::RangeInclusiveCopy => GenericRequirement::None,
            LangItem::RangeToInclusiveCopy => GenericRequirement::None,
            LangItem::String => GenericRequirement::None,
            LangItem::CStr => GenericRequirement::None,
            LangItem::ContractBuildCheckEnsures => GenericRequirement::None,
            LangItem::ContractCheckRequires => GenericRequirement::None,
            LangItem::DefaultTrait4 => GenericRequirement::None,
            LangItem::DefaultTrait3 => GenericRequirement::None,
            LangItem::DefaultTrait2 => GenericRequirement::None,
            LangItem::DefaultTrait1 => GenericRequirement::None,
            LangItem::ContractCheckEnsures => GenericRequirement::None,
            LangItem::Reborrow => GenericRequirement::Exact(0),
            LangItem::CoerceShared => GenericRequirement::Exact(0),
        }
    }
}
impl LanguageItems {
    #[doc =
    "Returns the [`DefId`] of the `sized` lang item if it is defined."]
    pub fn sized_trait(&self) -> Option<DefId> {
        self.items[LangItem::Sized as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `meta_sized` lang item if it is defined."]
    pub fn meta_sized_trait(&self) -> Option<DefId> {
        self.items[LangItem::MetaSized as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `pointee_sized` lang item if it is defined."]
    pub fn pointee_sized_trait(&self) -> Option<DefId> {
        self.items[LangItem::PointeeSized as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `unsize` lang item if it is defined."]
    pub fn unsize_trait(&self) -> Option<DefId> {
        self.items[LangItem::Unsize as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `mem_align_const` lang item if it is defined."]
    pub fn align_const(&self) -> Option<DefId> {
        self.items[LangItem::AlignOf as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `mem_size_const` lang item if it is defined."]
    pub fn size_const(&self) -> Option<DefId> {
        self.items[LangItem::SizeOf as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `offset_of` lang item if it is defined."]
    pub fn offset_of(&self) -> Option<DefId> {
        self.items[LangItem::OffsetOf as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `structural_peq` lang item if it is defined."]
    pub fn structural_peq_trait(&self) -> Option<DefId> {
        self.items[LangItem::StructuralPeq as usize]
    }
    #[doc = "Returns the [`DefId`] of the `copy` lang item if it is defined."]
    pub fn copy_trait(&self) -> Option<DefId> {
        self.items[LangItem::Copy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `clone` lang item if it is defined."]
    pub fn clone_trait(&self) -> Option<DefId> {
        self.items[LangItem::Clone as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `clone_fn` lang item if it is defined."]
    pub fn clone_fn(&self) -> Option<DefId> {
        self.items[LangItem::CloneFn as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `use_cloned` lang item if it is defined."]
    pub fn use_cloned_trait(&self) -> Option<DefId> {
        self.items[LangItem::UseCloned as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `trivial_clone` lang item if it is defined."]
    pub fn trivial_clone_trait(&self) -> Option<DefId> {
        self.items[LangItem::TrivialClone as usize]
    }
    #[doc = "Returns the [`DefId`] of the `sync` lang item if it is defined."]
    pub fn sync_trait(&self) -> Option<DefId> {
        self.items[LangItem::Sync as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `discriminant_kind` lang item if it is defined."]
    pub fn discriminant_kind_trait(&self) -> Option<DefId> {
        self.items[LangItem::DiscriminantKind as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `discriminant_type` lang item if it is defined."]
    pub fn discriminant_type(&self) -> Option<DefId> {
        self.items[LangItem::Discriminant as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `pointee_trait` lang item if it is defined."]
    pub fn pointee_trait(&self) -> Option<DefId> {
        self.items[LangItem::PointeeTrait as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `metadata_type` lang item if it is defined."]
    pub fn metadata_type(&self) -> Option<DefId> {
        self.items[LangItem::Metadata as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `dyn_metadata` lang item if it is defined."]
    pub fn dyn_metadata(&self) -> Option<DefId> {
        self.items[LangItem::DynMetadata as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `freeze` lang item if it is defined."]
    pub fn freeze_trait(&self) -> Option<DefId> {
        self.items[LangItem::Freeze as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `unsafe_unpin` lang item if it is defined."]
    pub fn unsafe_unpin_trait(&self) -> Option<DefId> {
        self.items[LangItem::UnsafeUnpin as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `fn_ptr_trait` lang item if it is defined."]
    pub fn fn_ptr_trait(&self) -> Option<DefId> {
        self.items[LangItem::FnPtrTrait as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `fn_ptr_addr` lang item if it is defined."]
    pub fn fn_ptr_addr(&self) -> Option<DefId> {
        self.items[LangItem::FnPtrAddr as usize]
    }
    #[doc = "Returns the [`DefId`] of the `drop` lang item if it is defined."]
    pub fn drop_trait(&self) -> Option<DefId> {
        self.items[LangItem::Drop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `destruct` lang item if it is defined."]
    pub fn destruct_trait(&self) -> Option<DefId> {
        self.items[LangItem::Destruct as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_drop` lang item if it is defined."]
    pub fn async_drop_trait(&self) -> Option<DefId> {
        self.items[LangItem::AsyncDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_drop_in_place` lang item if it is defined."]
    pub fn async_drop_in_place_fn(&self) -> Option<DefId> {
        self.items[LangItem::AsyncDropInPlace as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coerce_unsized` lang item if it is defined."]
    pub fn coerce_unsized_trait(&self) -> Option<DefId> {
        self.items[LangItem::CoerceUnsized as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `dispatch_from_dyn` lang item if it is defined."]
    pub fn dispatch_from_dyn_trait(&self) -> Option<DefId> {
        self.items[LangItem::DispatchFromDyn as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `transmute_opts` lang item if it is defined."]
    pub fn transmute_opts(&self) -> Option<DefId> {
        self.items[LangItem::TransmuteOpts as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `transmute_trait` lang item if it is defined."]
    pub fn transmute_trait(&self) -> Option<DefId> {
        self.items[LangItem::TransmuteTrait as usize]
    }
    #[doc = "Returns the [`DefId`] of the `add` lang item if it is defined."]
    pub fn add_trait(&self) -> Option<DefId> {
        self.items[LangItem::Add as usize]
    }
    #[doc = "Returns the [`DefId`] of the `sub` lang item if it is defined."]
    pub fn sub_trait(&self) -> Option<DefId> {
        self.items[LangItem::Sub as usize]
    }
    #[doc = "Returns the [`DefId`] of the `mul` lang item if it is defined."]
    pub fn mul_trait(&self) -> Option<DefId> {
        self.items[LangItem::Mul as usize]
    }
    #[doc = "Returns the [`DefId`] of the `div` lang item if it is defined."]
    pub fn div_trait(&self) -> Option<DefId> {
        self.items[LangItem::Div as usize]
    }
    #[doc = "Returns the [`DefId`] of the `rem` lang item if it is defined."]
    pub fn rem_trait(&self) -> Option<DefId> {
        self.items[LangItem::Rem as usize]
    }
    #[doc = "Returns the [`DefId`] of the `neg` lang item if it is defined."]
    pub fn neg_trait(&self) -> Option<DefId> {
        self.items[LangItem::Neg as usize]
    }
    #[doc = "Returns the [`DefId`] of the `not` lang item if it is defined."]
    pub fn not_trait(&self) -> Option<DefId> {
        self.items[LangItem::Not as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bitxor` lang item if it is defined."]
    pub fn bitxor_trait(&self) -> Option<DefId> {
        self.items[LangItem::BitXor as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bitand` lang item if it is defined."]
    pub fn bitand_trait(&self) -> Option<DefId> {
        self.items[LangItem::BitAnd as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bitor` lang item if it is defined."]
    pub fn bitor_trait(&self) -> Option<DefId> {
        self.items[LangItem::BitOr as usize]
    }
    #[doc = "Returns the [`DefId`] of the `shl` lang item if it is defined."]
    pub fn shl_trait(&self) -> Option<DefId> {
        self.items[LangItem::Shl as usize]
    }
    #[doc = "Returns the [`DefId`] of the `shr` lang item if it is defined."]
    pub fn shr_trait(&self) -> Option<DefId> {
        self.items[LangItem::Shr as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `add_assign` lang item if it is defined."]
    pub fn add_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::AddAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `sub_assign` lang item if it is defined."]
    pub fn sub_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::SubAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `mul_assign` lang item if it is defined."]
    pub fn mul_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::MulAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `div_assign` lang item if it is defined."]
    pub fn div_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::DivAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `rem_assign` lang item if it is defined."]
    pub fn rem_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::RemAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bitxor_assign` lang item if it is defined."]
    pub fn bitxor_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::BitXorAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bitand_assign` lang item if it is defined."]
    pub fn bitand_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::BitAndAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bitor_assign` lang item if it is defined."]
    pub fn bitor_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::BitOrAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `shl_assign` lang item if it is defined."]
    pub fn shl_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::ShlAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `shr_assign` lang item if it is defined."]
    pub fn shr_assign_trait(&self) -> Option<DefId> {
        self.items[LangItem::ShrAssign as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `index` lang item if it is defined."]
    pub fn index_trait(&self) -> Option<DefId> {
        self.items[LangItem::Index as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `index_mut` lang item if it is defined."]
    pub fn index_mut_trait(&self) -> Option<DefId> {
        self.items[LangItem::IndexMut as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `unsafe_cell` lang item if it is defined."]
    pub fn unsafe_cell_type(&self) -> Option<DefId> {
        self.items[LangItem::UnsafeCell as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `unsafe_pinned` lang item if it is defined."]
    pub fn unsafe_pinned_type(&self) -> Option<DefId> {
        self.items[LangItem::UnsafePinned as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `va_list` lang item if it is defined."]
    pub fn va_list(&self) -> Option<DefId> {
        self.items[LangItem::VaList as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `deref` lang item if it is defined."]
    pub fn deref_trait(&self) -> Option<DefId> {
        self.items[LangItem::Deref as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `deref_mut` lang item if it is defined."]
    pub fn deref_mut_trait(&self) -> Option<DefId> {
        self.items[LangItem::DerefMut as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `deref_pure` lang item if it is defined."]
    pub fn deref_pure_trait(&self) -> Option<DefId> {
        self.items[LangItem::DerefPure as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `deref_target` lang item if it is defined."]
    pub fn deref_target(&self) -> Option<DefId> {
        self.items[LangItem::DerefTarget as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `receiver` lang item if it is defined."]
    pub fn receiver_trait(&self) -> Option<DefId> {
        self.items[LangItem::Receiver as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `receiver_target` lang item if it is defined."]
    pub fn receiver_target(&self) -> Option<DefId> {
        self.items[LangItem::ReceiverTarget as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `legacy_receiver` lang item if it is defined."]
    pub fn legacy_receiver_trait(&self) -> Option<DefId> {
        self.items[LangItem::LegacyReceiver as usize]
    }
    #[doc = "Returns the [`DefId`] of the `Fn` lang item if it is defined."]
    pub fn fn_trait(&self) -> Option<DefId> {
        self.items[LangItem::Fn as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `fn_mut` lang item if it is defined."]
    pub fn fn_mut_trait(&self) -> Option<DefId> {
        self.items[LangItem::FnMut as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `fn_once` lang item if it is defined."]
    pub fn fn_once_trait(&self) -> Option<DefId> {
        self.items[LangItem::FnOnce as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_fn` lang item if it is defined."]
    pub fn async_fn_trait(&self) -> Option<DefId> {
        self.items[LangItem::AsyncFn as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_fn_mut` lang item if it is defined."]
    pub fn async_fn_mut_trait(&self) -> Option<DefId> {
        self.items[LangItem::AsyncFnMut as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_fn_once` lang item if it is defined."]
    pub fn async_fn_once_trait(&self) -> Option<DefId> {
        self.items[LangItem::AsyncFnOnce as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_fn_once_output` lang item if it is defined."]
    pub fn async_fn_once_output(&self) -> Option<DefId> {
        self.items[LangItem::AsyncFnOnceOutput as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `call_once_future` lang item if it is defined."]
    pub fn call_once_future(&self) -> Option<DefId> {
        self.items[LangItem::CallOnceFuture as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `call_ref_future` lang item if it is defined."]
    pub fn call_ref_future(&self) -> Option<DefId> {
        self.items[LangItem::CallRefFuture as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_fn_kind_helper` lang item if it is defined."]
    pub fn async_fn_kind_helper(&self) -> Option<DefId> {
        self.items[LangItem::AsyncFnKindHelper as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_fn_kind_upvars` lang item if it is defined."]
    pub fn async_fn_kind_upvars(&self) -> Option<DefId> {
        self.items[LangItem::AsyncFnKindUpvars as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `fn_once_output` lang item if it is defined."]
    pub fn fn_once_output(&self) -> Option<DefId> {
        self.items[LangItem::FnOnceOutput as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `iterator` lang item if it is defined."]
    pub fn iterator_trait(&self) -> Option<DefId> {
        self.items[LangItem::Iterator as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `fused_iterator` lang item if it is defined."]
    pub fn fused_iterator_trait(&self) -> Option<DefId> {
        self.items[LangItem::FusedIterator as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `future_trait` lang item if it is defined."]
    pub fn future_trait(&self) -> Option<DefId> {
        self.items[LangItem::Future as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `future_output` lang item if it is defined."]
    pub fn future_output(&self) -> Option<DefId> {
        self.items[LangItem::FutureOutput as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_iterator` lang item if it is defined."]
    pub fn async_iterator_trait(&self) -> Option<DefId> {
        self.items[LangItem::AsyncIterator as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coroutine_state` lang item if it is defined."]
    pub fn coroutine_state(&self) -> Option<DefId> {
        self.items[LangItem::CoroutineState as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coroutine` lang item if it is defined."]
    pub fn coroutine_trait(&self) -> Option<DefId> {
        self.items[LangItem::Coroutine as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coroutine_return` lang item if it is defined."]
    pub fn coroutine_return(&self) -> Option<DefId> {
        self.items[LangItem::CoroutineReturn as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coroutine_yield` lang item if it is defined."]
    pub fn coroutine_yield(&self) -> Option<DefId> {
        self.items[LangItem::CoroutineYield as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coroutine_resume` lang item if it is defined."]
    pub fn coroutine_resume(&self) -> Option<DefId> {
        self.items[LangItem::CoroutineResume as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `unpin` lang item if it is defined."]
    pub fn unpin_trait(&self) -> Option<DefId> {
        self.items[LangItem::Unpin as usize]
    }
    #[doc = "Returns the [`DefId`] of the `pin` lang item if it is defined."]
    pub fn pin_type(&self) -> Option<DefId> {
        self.items[LangItem::Pin as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Ordering` lang item if it is defined."]
    pub fn ordering_enum(&self) -> Option<DefId> {
        self.items[LangItem::OrderingEnum as usize]
    }
    #[doc = "Returns the [`DefId`] of the `eq` lang item if it is defined."]
    pub fn eq_trait(&self) -> Option<DefId> {
        self.items[LangItem::PartialEq as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `partial_ord` lang item if it is defined."]
    pub fn partial_ord_trait(&self) -> Option<DefId> {
        self.items[LangItem::PartialOrd as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `c_void` lang item if it is defined."]
    pub fn c_void(&self) -> Option<DefId> {
        self.items[LangItem::CVoid as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `type_info` lang item if it is defined."]
    pub fn type_struct(&self) -> Option<DefId> {
        self.items[LangItem::Type as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `type_id` lang item if it is defined."]
    pub fn type_id(&self) -> Option<DefId> {
        self.items[LangItem::TypeId as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic` lang item if it is defined."]
    pub fn panic_fn(&self) -> Option<DefId> {
        self.items[LangItem::Panic as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_nounwind` lang item if it is defined."]
    pub fn panic_nounwind(&self) -> Option<DefId> {
        self.items[LangItem::PanicNounwind as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_fmt` lang item if it is defined."]
    pub fn panic_fmt(&self) -> Option<DefId> {
        self.items[LangItem::PanicFmt as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_display` lang item if it is defined."]
    pub fn panic_display(&self) -> Option<DefId> {
        self.items[LangItem::PanicDisplay as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `const_panic_fmt` lang item if it is defined."]
    pub fn const_panic_fmt(&self) -> Option<DefId> {
        self.items[LangItem::ConstPanicFmt as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_bounds_check` lang item if it is defined."]
    pub fn panic_bounds_check_fn(&self) -> Option<DefId> {
        self.items[LangItem::PanicBoundsCheck as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_misaligned_pointer_dereference` lang item if it is defined."]
    pub fn panic_misaligned_pointer_dereference_fn(&self) -> Option<DefId> {
        self.items[LangItem::PanicMisalignedPointerDereference as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_info` lang item if it is defined."]
    pub fn panic_info(&self) -> Option<DefId> {
        self.items[LangItem::PanicInfo as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_location` lang item if it is defined."]
    pub fn panic_location(&self) -> Option<DefId> {
        self.items[LangItem::PanicLocation as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_impl` lang item if it is defined."]
    pub fn panic_impl(&self) -> Option<DefId> {
        self.items[LangItem::PanicImpl as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_cannot_unwind` lang item if it is defined."]
    pub fn panic_cannot_unwind(&self) -> Option<DefId> {
        self.items[LangItem::PanicCannotUnwind as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_in_cleanup` lang item if it is defined."]
    pub fn panic_in_cleanup(&self) -> Option<DefId> {
        self.items[LangItem::PanicInCleanup as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_add_overflow` lang item if it is defined."]
    pub fn panic_const_add_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicAddOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_sub_overflow` lang item if it is defined."]
    pub fn panic_const_sub_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicSubOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_mul_overflow` lang item if it is defined."]
    pub fn panic_const_mul_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicMulOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_div_overflow` lang item if it is defined."]
    pub fn panic_const_div_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicDivOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_rem_overflow` lang item if it is defined."]
    pub fn panic_const_rem_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicRemOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_neg_overflow` lang item if it is defined."]
    pub fn panic_const_neg_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicNegOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_shr_overflow` lang item if it is defined."]
    pub fn panic_const_shr_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicShrOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_shl_overflow` lang item if it is defined."]
    pub fn panic_const_shl_overflow(&self) -> Option<DefId> {
        self.items[LangItem::PanicShlOverflow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_div_by_zero` lang item if it is defined."]
    pub fn panic_const_div_by_zero(&self) -> Option<DefId> {
        self.items[LangItem::PanicDivZero as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_rem_by_zero` lang item if it is defined."]
    pub fn panic_const_rem_by_zero(&self) -> Option<DefId> {
        self.items[LangItem::PanicRemZero as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_coroutine_resumed` lang item if it is defined."]
    pub fn panic_const_coroutine_resumed(&self) -> Option<DefId> {
        self.items[LangItem::PanicCoroutineResumed as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_async_fn_resumed` lang item if it is defined."]
    pub fn panic_const_async_fn_resumed(&self) -> Option<DefId> {
        self.items[LangItem::PanicAsyncFnResumed as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_async_gen_fn_resumed` lang item if it is defined."]
    pub fn panic_const_async_gen_fn_resumed(&self) -> Option<DefId> {
        self.items[LangItem::PanicAsyncGenFnResumed as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_gen_fn_none` lang item if it is defined."]
    pub fn panic_const_gen_fn_none(&self) -> Option<DefId> {
        self.items[LangItem::PanicGenFnNone as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_coroutine_resumed_panic` lang item if it is defined."]
    pub fn panic_const_coroutine_resumed_panic(&self) -> Option<DefId> {
        self.items[LangItem::PanicCoroutineResumedPanic as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_async_fn_resumed_panic` lang item if it is defined."]
    pub fn panic_const_async_fn_resumed_panic(&self) -> Option<DefId> {
        self.items[LangItem::PanicAsyncFnResumedPanic as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_async_gen_fn_resumed_panic` lang item if it is defined."]
    pub fn panic_const_async_gen_fn_resumed_panic(&self) -> Option<DefId> {
        self.items[LangItem::PanicAsyncGenFnResumedPanic as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_gen_fn_none_panic` lang item if it is defined."]
    pub fn panic_const_gen_fn_none_panic(&self) -> Option<DefId> {
        self.items[LangItem::PanicGenFnNonePanic as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_null_pointer_dereference` lang item if it is defined."]
    pub fn panic_null_pointer_dereference(&self) -> Option<DefId> {
        self.items[LangItem::PanicNullPointerDereference as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_invalid_enum_construction` lang item if it is defined."]
    pub fn panic_invalid_enum_construction(&self) -> Option<DefId> {
        self.items[LangItem::PanicInvalidEnumConstruction as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_coroutine_resumed_drop` lang item if it is defined."]
    pub fn panic_const_coroutine_resumed_drop(&self) -> Option<DefId> {
        self.items[LangItem::PanicCoroutineResumedDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_async_fn_resumed_drop` lang item if it is defined."]
    pub fn panic_const_async_fn_resumed_drop(&self) -> Option<DefId> {
        self.items[LangItem::PanicAsyncFnResumedDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_async_gen_fn_resumed_drop` lang item if it is defined."]
    pub fn panic_const_async_gen_fn_resumed_drop(&self) -> Option<DefId> {
        self.items[LangItem::PanicAsyncGenFnResumedDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `panic_const_gen_fn_none_drop` lang item if it is defined."]
    pub fn panic_const_gen_fn_none_drop(&self) -> Option<DefId> {
        self.items[LangItem::PanicGenFnNoneDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `begin_panic` lang item if it is defined."]
    pub fn begin_panic_fn(&self) -> Option<DefId> {
        self.items[LangItem::BeginPanic as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `format_argument` lang item if it is defined."]
    pub fn format_argument(&self) -> Option<DefId> {
        self.items[LangItem::FormatArgument as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `format_arguments` lang item if it is defined."]
    pub fn format_arguments(&self) -> Option<DefId> {
        self.items[LangItem::FormatArguments as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `exchange_malloc` lang item if it is defined."]
    pub fn exchange_malloc_fn(&self) -> Option<DefId> {
        self.items[LangItem::ExchangeMalloc as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `drop_in_place` lang item if it is defined."]
    pub fn drop_in_place_fn(&self) -> Option<DefId> {
        self.items[LangItem::DropInPlace as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `alloc_layout` lang item if it is defined."]
    pub fn alloc_layout(&self) -> Option<DefId> {
        self.items[LangItem::AllocLayout as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `start` lang item if it is defined."]
    pub fn start_fn(&self) -> Option<DefId> {
        self.items[LangItem::Start as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `eh_personality` lang item if it is defined."]
    pub fn eh_personality(&self) -> Option<DefId> {
        self.items[LangItem::EhPersonality as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `eh_catch_typeinfo` lang item if it is defined."]
    pub fn eh_catch_typeinfo(&self) -> Option<DefId> {
        self.items[LangItem::EhCatchTypeinfo as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `compiler_move` lang item if it is defined."]
    pub fn compiler_move_fn(&self) -> Option<DefId> {
        self.items[LangItem::CompilerMove as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `compiler_copy` lang item if it is defined."]
    pub fn compiler_copy_fn(&self) -> Option<DefId> {
        self.items[LangItem::CompilerCopy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `owned_box` lang item if it is defined."]
    pub fn owned_box(&self) -> Option<DefId> {
        self.items[LangItem::OwnedBox as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `global_alloc_ty` lang item if it is defined."]
    pub fn global_alloc_ty(&self) -> Option<DefId> {
        self.items[LangItem::GlobalAlloc as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `phantom_data` lang item if it is defined."]
    pub fn phantom_data(&self) -> Option<DefId> {
        self.items[LangItem::PhantomData as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `manually_drop` lang item if it is defined."]
    pub fn manually_drop(&self) -> Option<DefId> {
        self.items[LangItem::ManuallyDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `bikeshed_guaranteed_no_drop` lang item if it is defined."]
    pub fn bikeshed_guaranteed_no_drop(&self) -> Option<DefId> {
        self.items[LangItem::BikeshedGuaranteedNoDrop as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `maybe_uninit` lang item if it is defined."]
    pub fn maybe_uninit(&self) -> Option<DefId> {
        self.items[LangItem::MaybeUninit as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `termination` lang item if it is defined."]
    pub fn termination(&self) -> Option<DefId> {
        self.items[LangItem::Termination as usize]
    }
    #[doc = "Returns the [`DefId`] of the `Try` lang item if it is defined."]
    pub fn try_trait(&self) -> Option<DefId> {
        self.items[LangItem::Try as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `tuple_trait` lang item if it is defined."]
    pub fn tuple_trait(&self) -> Option<DefId> {
        self.items[LangItem::Tuple as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `slice_len_fn` lang item if it is defined."]
    pub fn slice_len_fn(&self) -> Option<DefId> {
        self.items[LangItem::SliceLen as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `from_residual` lang item if it is defined."]
    pub fn from_residual_fn(&self) -> Option<DefId> {
        self.items[LangItem::TryTraitFromResidual as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `from_output` lang item if it is defined."]
    pub fn from_output_fn(&self) -> Option<DefId> {
        self.items[LangItem::TryTraitFromOutput as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `branch` lang item if it is defined."]
    pub fn branch_fn(&self) -> Option<DefId> {
        self.items[LangItem::TryTraitBranch as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `from_yeet` lang item if it is defined."]
    pub fn from_yeet_fn(&self) -> Option<DefId> {
        self.items[LangItem::TryTraitFromYeet as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `into_try_type` lang item if it is defined."]
    pub fn into_try_type_fn(&self) -> Option<DefId> {
        self.items[LangItem::ResidualIntoTryType as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coerce_pointee_validated` lang item if it is defined."]
    pub fn coerce_pointee_validated_trait(&self) -> Option<DefId> {
        self.items[LangItem::CoercePointeeValidated as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `const_param_ty` lang item if it is defined."]
    pub fn const_param_ty_trait(&self) -> Option<DefId> {
        self.items[LangItem::ConstParamTy as usize]
    }
    #[doc = "Returns the [`DefId`] of the `Poll` lang item if it is defined."]
    pub fn poll(&self) -> Option<DefId> {
        self.items[LangItem::Poll as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Ready` lang item if it is defined."]
    pub fn poll_ready_variant(&self) -> Option<DefId> {
        self.items[LangItem::PollReady as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Pending` lang item if it is defined."]
    pub fn poll_pending_variant(&self) -> Option<DefId> {
        self.items[LangItem::PollPending as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `AsyncGenReady` lang item if it is defined."]
    pub fn async_gen_ready(&self) -> Option<DefId> {
        self.items[LangItem::AsyncGenReady as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `AsyncGenPending` lang item if it is defined."]
    pub fn async_gen_pending(&self) -> Option<DefId> {
        self.items[LangItem::AsyncGenPending as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `AsyncGenFinished` lang item if it is defined."]
    pub fn async_gen_finished(&self) -> Option<DefId> {
        self.items[LangItem::AsyncGenFinished as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `ResumeTy` lang item if it is defined."]
    pub fn resume_ty(&self) -> Option<DefId> {
        self.items[LangItem::ResumeTy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `get_context` lang item if it is defined."]
    pub fn get_context_fn(&self) -> Option<DefId> {
        self.items[LangItem::GetContext as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Context` lang item if it is defined."]
    pub fn context(&self) -> Option<DefId> {
        self.items[LangItem::Context as usize]
    }
    #[doc = "Returns the [`DefId`] of the `poll` lang item if it is defined."]
    pub fn future_poll_fn(&self) -> Option<DefId> {
        self.items[LangItem::FuturePoll as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `async_iterator_poll_next` lang item if it is defined."]
    pub fn async_iterator_poll_next(&self) -> Option<DefId> {
        self.items[LangItem::AsyncIteratorPollNext as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `into_async_iter_into_iter` lang item if it is defined."]
    pub fn into_async_iter_into_iter(&self) -> Option<DefId> {
        self.items[LangItem::IntoAsyncIterIntoIter as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Option` lang item if it is defined."]
    pub fn option_type(&self) -> Option<DefId> {
        self.items[LangItem::Option as usize]
    }
    #[doc = "Returns the [`DefId`] of the `Some` lang item if it is defined."]
    pub fn option_some_variant(&self) -> Option<DefId> {
        self.items[LangItem::OptionSome as usize]
    }
    #[doc = "Returns the [`DefId`] of the `None` lang item if it is defined."]
    pub fn option_none_variant(&self) -> Option<DefId> {
        self.items[LangItem::OptionNone as usize]
    }
    #[doc = "Returns the [`DefId`] of the `Ok` lang item if it is defined."]
    pub fn result_ok_variant(&self) -> Option<DefId> {
        self.items[LangItem::ResultOk as usize]
    }
    #[doc = "Returns the [`DefId`] of the `Err` lang item if it is defined."]
    pub fn result_err_variant(&self) -> Option<DefId> {
        self.items[LangItem::ResultErr as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Continue` lang item if it is defined."]
    pub fn cf_continue_variant(&self) -> Option<DefId> {
        self.items[LangItem::ControlFlowContinue as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Break` lang item if it is defined."]
    pub fn cf_break_variant(&self) -> Option<DefId> {
        self.items[LangItem::ControlFlowBreak as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `into_future` lang item if it is defined."]
    pub fn into_future_fn(&self) -> Option<DefId> {
        self.items[LangItem::IntoFutureIntoFuture as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `into_iter` lang item if it is defined."]
    pub fn into_iter_fn(&self) -> Option<DefId> {
        self.items[LangItem::IntoIterIntoIter as usize]
    }
    #[doc = "Returns the [`DefId`] of the `next` lang item if it is defined."]
    pub fn next_fn(&self) -> Option<DefId> {
        self.items[LangItem::IteratorNext as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `new_unchecked` lang item if it is defined."]
    pub fn new_unchecked_fn(&self) -> Option<DefId> {
        self.items[LangItem::PinNewUnchecked as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeFrom` lang item if it is defined."]
    pub fn range_from_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeFrom as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeFull` lang item if it is defined."]
    pub fn range_full_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeFull as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeInclusive` lang item if it is defined."]
    pub fn range_inclusive_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeInclusiveStruct as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `range_inclusive_new` lang item if it is defined."]
    pub fn range_inclusive_new_method(&self) -> Option<DefId> {
        self.items[LangItem::RangeInclusiveNew as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `Range` lang item if it is defined."]
    pub fn range_struct(&self) -> Option<DefId> {
        self.items[LangItem::Range as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeToInclusive` lang item if it is defined."]
    pub fn range_to_inclusive_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeToInclusive as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeTo` lang item if it is defined."]
    pub fn range_to_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeTo as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeMax` lang item if it is defined."]
    pub fn range_max(&self) -> Option<DefId> {
        self.items[LangItem::RangeMax as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeMin` lang item if it is defined."]
    pub fn range_min(&self) -> Option<DefId> {
        self.items[LangItem::RangeMin as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeSub` lang item if it is defined."]
    pub fn range_sub(&self) -> Option<DefId> {
        self.items[LangItem::RangeSub as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeFromCopy` lang item if it is defined."]
    pub fn range_from_copy_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeFromCopy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeCopy` lang item if it is defined."]
    pub fn range_copy_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeCopy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeInclusiveCopy` lang item if it is defined."]
    pub fn range_inclusive_copy_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeInclusiveCopy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `RangeToInclusiveCopy` lang item if it is defined."]
    pub fn range_to_inclusive_copy_struct(&self) -> Option<DefId> {
        self.items[LangItem::RangeToInclusiveCopy as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `String` lang item if it is defined."]
    pub fn string(&self) -> Option<DefId> {
        self.items[LangItem::String as usize]
    }
    #[doc = "Returns the [`DefId`] of the `CStr` lang item if it is defined."]
    pub fn c_str(&self) -> Option<DefId> {
        self.items[LangItem::CStr as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `contract_build_check_ensures` lang item if it is defined."]
    pub fn contract_build_check_ensures_fn(&self) -> Option<DefId> {
        self.items[LangItem::ContractBuildCheckEnsures as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `contract_check_requires` lang item if it is defined."]
    pub fn contract_check_requires_fn(&self) -> Option<DefId> {
        self.items[LangItem::ContractCheckRequires as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `default_trait4` lang item if it is defined."]
    pub fn default_trait4_trait(&self) -> Option<DefId> {
        self.items[LangItem::DefaultTrait4 as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `default_trait3` lang item if it is defined."]
    pub fn default_trait3_trait(&self) -> Option<DefId> {
        self.items[LangItem::DefaultTrait3 as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `default_trait2` lang item if it is defined."]
    pub fn default_trait2_trait(&self) -> Option<DefId> {
        self.items[LangItem::DefaultTrait2 as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `default_trait1` lang item if it is defined."]
    pub fn default_trait1_trait(&self) -> Option<DefId> {
        self.items[LangItem::DefaultTrait1 as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `contract_check_ensures` lang item if it is defined."]
    pub fn contract_check_ensures_fn(&self) -> Option<DefId> {
        self.items[LangItem::ContractCheckEnsures as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `reborrow` lang item if it is defined."]
    pub fn reborrow(&self) -> Option<DefId> {
        self.items[LangItem::Reborrow as usize]
    }
    #[doc =
    "Returns the [`DefId`] of the `coerce_shared` lang item if it is defined."]
    pub fn coerce_shared(&self) -> Option<DefId> {
        self.items[LangItem::CoerceShared as usize]
    }
}language_item_table! {
166//  Variant name,            Name,                     Getter method name,         Target                  Generic requirements;
167    Sized,                   sym::sized,               sized_trait,                Target::Trait,          GenericRequirement::Exact(0);
168    MetaSized,               sym::meta_sized,          meta_sized_trait,           Target::Trait,          GenericRequirement::Exact(0);
169    PointeeSized,            sym::pointee_sized,       pointee_sized_trait,        Target::Trait,          GenericRequirement::Exact(0);
170    Unsize,                  sym::unsize,              unsize_trait,               Target::Trait,          GenericRequirement::Minimum(1);
171    AlignOf,                 sym::mem_align_const,     align_const,                Target::AssocConst,     GenericRequirement::Exact(0);
172    SizeOf,                  sym::mem_size_const,      size_const,                 Target::AssocConst,     GenericRequirement::Exact(0);
173    OffsetOf,                sym::offset_of,           offset_of,                  Target::Fn,             GenericRequirement::Exact(1);
174    /// Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ").
175    StructuralPeq,           sym::structural_peq,      structural_peq_trait,       Target::Trait,          GenericRequirement::None;
176    Copy,                    sym::copy,                copy_trait,                 Target::Trait,          GenericRequirement::Exact(0);
177    Clone,                   sym::clone,               clone_trait,                Target::Trait,          GenericRequirement::None;
178    CloneFn,                 sym::clone_fn,            clone_fn,                   Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
179    UseCloned,               sym::use_cloned,          use_cloned_trait,           Target::Trait,          GenericRequirement::None;
180    TrivialClone,            sym::trivial_clone,       trivial_clone_trait,        Target::Trait,          GenericRequirement::None;
181    Sync,                    sym::sync,                sync_trait,                 Target::Trait,          GenericRequirement::Exact(0);
182    DiscriminantKind,        sym::discriminant_kind,   discriminant_kind_trait,    Target::Trait,          GenericRequirement::None;
183    /// The associated item of the `DiscriminantKind` trait.
184    Discriminant,            sym::discriminant_type,   discriminant_type,          Target::AssocTy,        GenericRequirement::None;
185
186    PointeeTrait,            sym::pointee_trait,       pointee_trait,              Target::Trait,          GenericRequirement::None;
187    Metadata,                sym::metadata_type,       metadata_type,              Target::AssocTy,        GenericRequirement::None;
188    DynMetadata,             sym::dyn_metadata,        dyn_metadata,               Target::Struct,         GenericRequirement::None;
189
190    Freeze,                  sym::freeze,              freeze_trait,               Target::Trait,          GenericRequirement::Exact(0);
191    UnsafeUnpin,             sym::unsafe_unpin,        unsafe_unpin_trait,         Target::Trait,          GenericRequirement::Exact(0);
192
193    FnPtrTrait,              sym::fn_ptr_trait,        fn_ptr_trait,               Target::Trait,          GenericRequirement::Exact(0);
194    FnPtrAddr,               sym::fn_ptr_addr,         fn_ptr_addr,                Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
195
196    Drop,                    sym::drop,                drop_trait,                 Target::Trait,          GenericRequirement::None;
197    Destruct,                sym::destruct,            destruct_trait,             Target::Trait,          GenericRequirement::None;
198    AsyncDrop,               sym::async_drop,          async_drop_trait,           Target::Trait,          GenericRequirement::None;
199    AsyncDropInPlace,        sym::async_drop_in_place, async_drop_in_place_fn,     Target::Fn,             GenericRequirement::Exact(1);
200
201    CoerceUnsized,           sym::coerce_unsized,      coerce_unsized_trait,       Target::Trait,          GenericRequirement::Minimum(1);
202    DispatchFromDyn,         sym::dispatch_from_dyn,   dispatch_from_dyn_trait,    Target::Trait,          GenericRequirement::Minimum(1);
203
204    // lang items relating to transmutability
205    TransmuteOpts,           sym::transmute_opts,      transmute_opts,             Target::Struct,         GenericRequirement::Exact(0);
206    TransmuteTrait,          sym::transmute_trait,     transmute_trait,            Target::Trait,          GenericRequirement::Exact(2);
207
208    Add,                     sym::add,                 add_trait,                  Target::Trait,          GenericRequirement::Exact(1);
209    Sub,                     sym::sub,                 sub_trait,                  Target::Trait,          GenericRequirement::Exact(1);
210    Mul,                     sym::mul,                 mul_trait,                  Target::Trait,          GenericRequirement::Exact(1);
211    Div,                     sym::div,                 div_trait,                  Target::Trait,          GenericRequirement::Exact(1);
212    Rem,                     sym::rem,                 rem_trait,                  Target::Trait,          GenericRequirement::Exact(1);
213    Neg,                     sym::neg,                 neg_trait,                  Target::Trait,          GenericRequirement::Exact(0);
214    Not,                     sym::not,                 not_trait,                  Target::Trait,          GenericRequirement::Exact(0);
215    BitXor,                  sym::bitxor,              bitxor_trait,               Target::Trait,          GenericRequirement::Exact(1);
216    BitAnd,                  sym::bitand,              bitand_trait,               Target::Trait,          GenericRequirement::Exact(1);
217    BitOr,                   sym::bitor,               bitor_trait,                Target::Trait,          GenericRequirement::Exact(1);
218    Shl,                     sym::shl,                 shl_trait,                  Target::Trait,          GenericRequirement::Exact(1);
219    Shr,                     sym::shr,                 shr_trait,                  Target::Trait,          GenericRequirement::Exact(1);
220    AddAssign,               sym::add_assign,          add_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
221    SubAssign,               sym::sub_assign,          sub_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
222    MulAssign,               sym::mul_assign,          mul_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
223    DivAssign,               sym::div_assign,          div_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
224    RemAssign,               sym::rem_assign,          rem_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
225    BitXorAssign,            sym::bitxor_assign,       bitxor_assign_trait,        Target::Trait,          GenericRequirement::Exact(1);
226    BitAndAssign,            sym::bitand_assign,       bitand_assign_trait,        Target::Trait,          GenericRequirement::Exact(1);
227    BitOrAssign,             sym::bitor_assign,        bitor_assign_trait,         Target::Trait,          GenericRequirement::Exact(1);
228    ShlAssign,               sym::shl_assign,          shl_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
229    ShrAssign,               sym::shr_assign,          shr_assign_trait,           Target::Trait,          GenericRequirement::Exact(1);
230    Index,                   sym::index,               index_trait,                Target::Trait,          GenericRequirement::Exact(1);
231    IndexMut,                sym::index_mut,           index_mut_trait,            Target::Trait,          GenericRequirement::Exact(1);
232
233    UnsafeCell,              sym::unsafe_cell,         unsafe_cell_type,           Target::Struct,         GenericRequirement::None;
234    UnsafePinned,            sym::unsafe_pinned,       unsafe_pinned_type,         Target::Struct,         GenericRequirement::None;
235
236    VaList,                  sym::va_list,             va_list,                    Target::Struct,         GenericRequirement::None;
237
238    Deref,                   sym::deref,               deref_trait,                Target::Trait,          GenericRequirement::Exact(0);
239    DerefMut,                sym::deref_mut,           deref_mut_trait,            Target::Trait,          GenericRequirement::Exact(0);
240    DerefPure,               sym::deref_pure,          deref_pure_trait,           Target::Trait,          GenericRequirement::Exact(0);
241    DerefTarget,             sym::deref_target,        deref_target,               Target::AssocTy,        GenericRequirement::None;
242    Receiver,                sym::receiver,            receiver_trait,             Target::Trait,          GenericRequirement::None;
243    ReceiverTarget,          sym::receiver_target,     receiver_target,            Target::AssocTy,        GenericRequirement::None;
244    LegacyReceiver,          sym::legacy_receiver,     legacy_receiver_trait,      Target::Trait,          GenericRequirement::None;
245
246    Fn,                      kw::Fn,                   fn_trait,                   Target::Trait,          GenericRequirement::Exact(1);
247    FnMut,                   sym::fn_mut,              fn_mut_trait,               Target::Trait,          GenericRequirement::Exact(1);
248    FnOnce,                  sym::fn_once,             fn_once_trait,              Target::Trait,          GenericRequirement::Exact(1);
249
250    AsyncFn,                 sym::async_fn,            async_fn_trait,             Target::Trait,          GenericRequirement::Exact(1);
251    AsyncFnMut,              sym::async_fn_mut,        async_fn_mut_trait,         Target::Trait,          GenericRequirement::Exact(1);
252    AsyncFnOnce,             sym::async_fn_once,       async_fn_once_trait,        Target::Trait,          GenericRequirement::Exact(1);
253    AsyncFnOnceOutput,       sym::async_fn_once_output, async_fn_once_output,       Target::AssocTy,        GenericRequirement::Exact(1);
254    CallOnceFuture,          sym::call_once_future,    call_once_future,           Target::AssocTy,        GenericRequirement::Exact(1);
255    CallRefFuture,           sym::call_ref_future,     call_ref_future,            Target::AssocTy,        GenericRequirement::Exact(2);
256    AsyncFnKindHelper,       sym::async_fn_kind_helper, async_fn_kind_helper,      Target::Trait,          GenericRequirement::Exact(1);
257    AsyncFnKindUpvars,       sym::async_fn_kind_upvars, async_fn_kind_upvars,      Target::AssocTy,          GenericRequirement::Exact(5);
258
259    FnOnceOutput,            sym::fn_once_output,      fn_once_output,             Target::AssocTy,        GenericRequirement::None;
260
261    Iterator,                sym::iterator,            iterator_trait,             Target::Trait,          GenericRequirement::Exact(0);
262    FusedIterator,           sym::fused_iterator,      fused_iterator_trait,       Target::Trait,          GenericRequirement::Exact(0);
263    Future,                  sym::future_trait,        future_trait,               Target::Trait,          GenericRequirement::Exact(0);
264    FutureOutput,            sym::future_output,       future_output,              Target::AssocTy,        GenericRequirement::Exact(0);
265    AsyncIterator,           sym::async_iterator,      async_iterator_trait,       Target::Trait,          GenericRequirement::Exact(0);
266
267    CoroutineState,          sym::coroutine_state,     coroutine_state,            Target::Enum,           GenericRequirement::None;
268    Coroutine,               sym::coroutine,           coroutine_trait,            Target::Trait,          GenericRequirement::Exact(1);
269    CoroutineReturn,         sym::coroutine_return,    coroutine_return,           Target::AssocTy,        GenericRequirement::Exact(1);
270    CoroutineYield,          sym::coroutine_yield,     coroutine_yield,            Target::AssocTy,        GenericRequirement::Exact(1);
271    CoroutineResume,         sym::coroutine_resume,    coroutine_resume,           Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
272
273    Unpin,                   sym::unpin,               unpin_trait,                Target::Trait,          GenericRequirement::None;
274    Pin,                     sym::pin,                 pin_type,                   Target::Struct,         GenericRequirement::None;
275
276    OrderingEnum,            sym::Ordering,            ordering_enum,              Target::Enum,           GenericRequirement::Exact(0);
277    PartialEq,               sym::eq,                  eq_trait,                   Target::Trait,          GenericRequirement::Exact(1);
278    PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
279    CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
280
281    Type,                    sym::type_info,           type_struct,                Target::Struct,         GenericRequirement::None;
282    TypeId,                  sym::type_id,             type_id,                    Target::Struct,         GenericRequirement::None;
283
284    // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and
285    // various panic cases with `match`. The `panic_bounds_check` item is for indexing arrays.
286    //
287    // The `begin_unwind` lang item has a predefined symbol name and is sort of a "weak lang item"
288    // in the sense that a crate is not required to have it defined to use it, but a final product
289    // is required to define it somewhere. Additionally, there are restrictions on crates that use
290    // a weak lang item, but do not have it defined.
291    Panic,                   sym::panic,               panic_fn,                   Target::Fn,             GenericRequirement::Exact(0);
292    PanicNounwind,           sym::panic_nounwind,      panic_nounwind,             Target::Fn,             GenericRequirement::Exact(0);
293    PanicFmt,                sym::panic_fmt,           panic_fmt,                  Target::Fn,             GenericRequirement::None;
294    PanicDisplay,            sym::panic_display,       panic_display,              Target::Fn,             GenericRequirement::None;
295    ConstPanicFmt,           sym::const_panic_fmt,     const_panic_fmt,            Target::Fn,             GenericRequirement::None;
296    PanicBoundsCheck,        sym::panic_bounds_check,  panic_bounds_check_fn,      Target::Fn,             GenericRequirement::Exact(0);
297    PanicMisalignedPointerDereference, sym::panic_misaligned_pointer_dereference, panic_misaligned_pointer_dereference_fn, Target::Fn, GenericRequirement::Exact(0);
298    PanicInfo,               sym::panic_info,          panic_info,                 Target::Struct,         GenericRequirement::None;
299    PanicLocation,           sym::panic_location,      panic_location,             Target::Struct,         GenericRequirement::None;
300    PanicImpl,               sym::panic_impl,          panic_impl,                 Target::Fn,             GenericRequirement::None;
301    PanicCannotUnwind,       sym::panic_cannot_unwind, panic_cannot_unwind,        Target::Fn,             GenericRequirement::Exact(0);
302    PanicInCleanup,          sym::panic_in_cleanup,    panic_in_cleanup,           Target::Fn,             GenericRequirement::Exact(0);
303    /// Constant panic messages, used for codegen of MIR asserts.
304    PanicAddOverflow,        sym::panic_const_add_overflow, panic_const_add_overflow, Target::Fn, GenericRequirement::None;
305    PanicSubOverflow,        sym::panic_const_sub_overflow, panic_const_sub_overflow, Target::Fn, GenericRequirement::None;
306    PanicMulOverflow,        sym::panic_const_mul_overflow, panic_const_mul_overflow, Target::Fn, GenericRequirement::None;
307    PanicDivOverflow,        sym::panic_const_div_overflow, panic_const_div_overflow, Target::Fn, GenericRequirement::None;
308    PanicRemOverflow,        sym::panic_const_rem_overflow, panic_const_rem_overflow, Target::Fn, GenericRequirement::None;
309    PanicNegOverflow,        sym::panic_const_neg_overflow, panic_const_neg_overflow, Target::Fn, GenericRequirement::None;
310    PanicShrOverflow,        sym::panic_const_shr_overflow, panic_const_shr_overflow, Target::Fn, GenericRequirement::None;
311    PanicShlOverflow,        sym::panic_const_shl_overflow, panic_const_shl_overflow, Target::Fn, GenericRequirement::None;
312    PanicDivZero,            sym::panic_const_div_by_zero, panic_const_div_by_zero, Target::Fn, GenericRequirement::None;
313    PanicRemZero,            sym::panic_const_rem_by_zero, panic_const_rem_by_zero, Target::Fn, GenericRequirement::None;
314    PanicCoroutineResumed, sym::panic_const_coroutine_resumed, panic_const_coroutine_resumed, Target::Fn, GenericRequirement::None;
315    PanicAsyncFnResumed, sym::panic_const_async_fn_resumed, panic_const_async_fn_resumed, Target::Fn, GenericRequirement::None;
316    PanicAsyncGenFnResumed, sym::panic_const_async_gen_fn_resumed, panic_const_async_gen_fn_resumed, Target::Fn, GenericRequirement::None;
317    PanicGenFnNone, sym::panic_const_gen_fn_none, panic_const_gen_fn_none, Target::Fn, GenericRequirement::None;
318    PanicCoroutineResumedPanic, sym::panic_const_coroutine_resumed_panic, panic_const_coroutine_resumed_panic, Target::Fn, GenericRequirement::None;
319    PanicAsyncFnResumedPanic, sym::panic_const_async_fn_resumed_panic, panic_const_async_fn_resumed_panic, Target::Fn, GenericRequirement::None;
320    PanicAsyncGenFnResumedPanic, sym::panic_const_async_gen_fn_resumed_panic, panic_const_async_gen_fn_resumed_panic, Target::Fn, GenericRequirement::None;
321    PanicGenFnNonePanic, sym::panic_const_gen_fn_none_panic, panic_const_gen_fn_none_panic, Target::Fn, GenericRequirement::None;
322    PanicNullPointerDereference, sym::panic_null_pointer_dereference, panic_null_pointer_dereference, Target::Fn, GenericRequirement::None;
323    PanicInvalidEnumConstruction, sym::panic_invalid_enum_construction, panic_invalid_enum_construction, Target::Fn, GenericRequirement::None;
324    PanicCoroutineResumedDrop, sym::panic_const_coroutine_resumed_drop, panic_const_coroutine_resumed_drop, Target::Fn, GenericRequirement::None;
325    PanicAsyncFnResumedDrop, sym::panic_const_async_fn_resumed_drop, panic_const_async_fn_resumed_drop, Target::Fn, GenericRequirement::None;
326    PanicAsyncGenFnResumedDrop, sym::panic_const_async_gen_fn_resumed_drop, panic_const_async_gen_fn_resumed_drop, Target::Fn, GenericRequirement::None;
327    PanicGenFnNoneDrop, sym::panic_const_gen_fn_none_drop, panic_const_gen_fn_none_drop, Target::Fn, GenericRequirement::None;
328    /// libstd panic entry point. Necessary for const eval to be able to catch it
329    BeginPanic,              sym::begin_panic,         begin_panic_fn,             Target::Fn,             GenericRequirement::None;
330
331    // Lang items needed for `format_args!()`.
332    FormatArgument,          sym::format_argument,     format_argument,            Target::Struct,         GenericRequirement::None;
333    FormatArguments,         sym::format_arguments,    format_arguments,           Target::Struct,         GenericRequirement::None;
334
335    ExchangeMalloc,          sym::exchange_malloc,     exchange_malloc_fn,         Target::Fn,             GenericRequirement::None;
336    DropInPlace,             sym::drop_in_place,       drop_in_place_fn,           Target::Fn,             GenericRequirement::Minimum(1);
337    AllocLayout,             sym::alloc_layout,        alloc_layout,               Target::Struct,         GenericRequirement::None;
338
339    /// For all binary crates without `#![no_main]`, Rust will generate a "main" function.
340    /// The exact name and signature are target-dependent. The "main" function will invoke
341    /// this lang item, passing it the `argc` and `argv` (or null, if those don't exist
342    /// on the current target) as well as the user-defined `fn main` from the binary crate.
343    Start,                   sym::start,               start_fn,                   Target::Fn,             GenericRequirement::Exact(1);
344
345    EhPersonality,           sym::eh_personality,      eh_personality,             Target::Fn,             GenericRequirement::None;
346    EhCatchTypeinfo,         sym::eh_catch_typeinfo,   eh_catch_typeinfo,          Target::Static,         GenericRequirement::None;
347
348    // Profiling markers for move/copy operations (used by -Z annotate-moves)
349    CompilerMove,            sym::compiler_move,       compiler_move_fn,           Target::Fn,             GenericRequirement::Exact(2);
350    CompilerCopy,            sym::compiler_copy,       compiler_copy_fn,           Target::Fn,             GenericRequirement::Exact(2);
351
352    OwnedBox,                sym::owned_box,           owned_box,                  Target::Struct,         GenericRequirement::Minimum(1);
353    GlobalAlloc,             sym::global_alloc_ty,     global_alloc_ty,            Target::Struct,         GenericRequirement::None;
354
355    PhantomData,             sym::phantom_data,        phantom_data,               Target::Struct,         GenericRequirement::Exact(1);
356
357    ManuallyDrop,            sym::manually_drop,       manually_drop,              Target::Struct,         GenericRequirement::None;
358    BikeshedGuaranteedNoDrop, sym::bikeshed_guaranteed_no_drop, bikeshed_guaranteed_no_drop, Target::Trait, GenericRequirement::Exact(0);
359
360    MaybeUninit,             sym::maybe_uninit,        maybe_uninit,               Target::Union,          GenericRequirement::None;
361
362    Termination,             sym::termination,         termination,                Target::Trait,          GenericRequirement::None;
363
364    Try,                     sym::Try,                 try_trait,                  Target::Trait,          GenericRequirement::None;
365
366    Tuple,                   sym::tuple_trait,         tuple_trait,                Target::Trait,          GenericRequirement::Exact(0);
367
368    SliceLen,                sym::slice_len_fn,        slice_len_fn,               Target::Method(MethodKind::Inherent), GenericRequirement::None;
369
370    // Language items from AST lowering
371    TryTraitFromResidual,    sym::from_residual,       from_residual_fn,           Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
372    TryTraitFromOutput,      sym::from_output,         from_output_fn,             Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
373    TryTraitBranch,          sym::branch,              branch_fn,                  Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
374    TryTraitFromYeet,        sym::from_yeet,           from_yeet_fn,               Target::Fn,             GenericRequirement::None;
375    ResidualIntoTryType,     sym::into_try_type,       into_try_type_fn,           Target::Fn,             GenericRequirement::None;
376
377    CoercePointeeValidated, sym::coerce_pointee_validated, coerce_pointee_validated_trait, Target::Trait,     GenericRequirement::Exact(0);
378
379    ConstParamTy,            sym::const_param_ty,      const_param_ty_trait,       Target::Trait,          GenericRequirement::Exact(0);
380
381    Poll,                    sym::Poll,                poll,                       Target::Enum,           GenericRequirement::None;
382    PollReady,               sym::Ready,               poll_ready_variant,         Target::Variant,        GenericRequirement::None;
383    PollPending,             sym::Pending,             poll_pending_variant,       Target::Variant,        GenericRequirement::None;
384
385    AsyncGenReady,           sym::AsyncGenReady,       async_gen_ready,            Target::Method(MethodKind::Inherent), GenericRequirement::Exact(1);
386    AsyncGenPending,         sym::AsyncGenPending,     async_gen_pending,          Target::AssocConst,     GenericRequirement::Exact(1);
387    AsyncGenFinished,        sym::AsyncGenFinished,    async_gen_finished,         Target::AssocConst,     GenericRequirement::Exact(1);
388
389    // FIXME(swatinem): the following lang items are used for async lowering and
390    // should become obsolete eventually.
391    ResumeTy,                sym::ResumeTy,            resume_ty,                  Target::Struct,         GenericRequirement::None;
392    GetContext,              sym::get_context,         get_context_fn,             Target::Fn,             GenericRequirement::None;
393
394    Context,                 sym::Context,             context,                    Target::Struct,         GenericRequirement::None;
395    FuturePoll,              sym::poll,                future_poll_fn,             Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
396
397    AsyncIteratorPollNext,   sym::async_iterator_poll_next, async_iterator_poll_next, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(0);
398    IntoAsyncIterIntoIter,   sym::into_async_iter_into_iter, into_async_iter_into_iter, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::Exact(0);
399
400    Option,                  sym::Option,              option_type,                Target::Enum,           GenericRequirement::None;
401    OptionSome,              sym::Some,                option_some_variant,        Target::Variant,        GenericRequirement::None;
402    OptionNone,              sym::None,                option_none_variant,        Target::Variant,        GenericRequirement::None;
403
404    ResultOk,                sym::Ok,                  result_ok_variant,          Target::Variant,        GenericRequirement::None;
405    ResultErr,               sym::Err,                 result_err_variant,         Target::Variant,        GenericRequirement::None;
406
407    ControlFlowContinue,     sym::Continue,            cf_continue_variant,        Target::Variant,        GenericRequirement::None;
408    ControlFlowBreak,        sym::Break,               cf_break_variant,           Target::Variant,        GenericRequirement::None;
409
410    IntoFutureIntoFuture,    sym::into_future,         into_future_fn,             Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
411    IntoIterIntoIter,        sym::into_iter,           into_iter_fn,               Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
412    IteratorNext,            sym::next,                next_fn,                    Target::Method(MethodKind::Trait { body: false}), GenericRequirement::None;
413
414    PinNewUnchecked,         sym::new_unchecked,       new_unchecked_fn,           Target::Method(MethodKind::Inherent), GenericRequirement::None;
415
416    RangeFrom,               sym::RangeFrom,           range_from_struct,          Target::Struct,         GenericRequirement::None;
417    RangeFull,               sym::RangeFull,           range_full_struct,          Target::Struct,         GenericRequirement::None;
418    RangeInclusiveStruct,    sym::RangeInclusive,      range_inclusive_struct,     Target::Struct,         GenericRequirement::None;
419    RangeInclusiveNew,       sym::range_inclusive_new, range_inclusive_new_method, Target::Method(MethodKind::Inherent), GenericRequirement::None;
420    Range,                   sym::Range,               range_struct,               Target::Struct,         GenericRequirement::None;
421    RangeToInclusive,        sym::RangeToInclusive,    range_to_inclusive_struct,  Target::Struct,         GenericRequirement::None;
422    RangeTo,                 sym::RangeTo,             range_to_struct,            Target::Struct,         GenericRequirement::None;
423    RangeMax,                sym::RangeMax,            range_max,                  Target::AssocConst,     GenericRequirement::Exact(0);
424    RangeMin,                sym::RangeMin,            range_min,                  Target::AssocConst,     GenericRequirement::Exact(0);
425    RangeSub,                sym::RangeSub,            range_sub,                  Target::Method(MethodKind::Trait { body: false }),     GenericRequirement::Exact(0);
426
427    // `new_range` types that are `Copy + IntoIterator`
428    RangeFromCopy,           sym::RangeFromCopy,       range_from_copy_struct,     Target::Struct,         GenericRequirement::None;
429    RangeCopy,               sym::RangeCopy,           range_copy_struct,          Target::Struct,         GenericRequirement::None;
430    RangeInclusiveCopy,      sym::RangeInclusiveCopy,  range_inclusive_copy_struct, Target::Struct,         GenericRequirement::None;
431    RangeToInclusiveCopy,    sym::RangeToInclusiveCopy,     range_to_inclusive_copy_struct, Target::Struct, GenericRequirement::None;
432
433    String,                  sym::String,              string,                     Target::Struct,         GenericRequirement::None;
434    CStr,                    sym::CStr,                c_str,                      Target::Struct,         GenericRequirement::None;
435
436    // Experimental lang items for implementing contract pre- and post-condition checking.
437    ContractBuildCheckEnsures, sym::contract_build_check_ensures, contract_build_check_ensures_fn, Target::Fn, GenericRequirement::None;
438    ContractCheckRequires,     sym::contract_check_requires,      contract_check_requires_fn,      Target::Fn, GenericRequirement::None;
439
440    // Experimental lang items for `MCP: Low level components for async drop`(https://github.com/rust-lang/compiler-team/issues/727)
441    DefaultTrait4,           sym::default_trait4,      default_trait4_trait,       Target::Trait,          GenericRequirement::None;
442    DefaultTrait3,           sym::default_trait3,      default_trait3_trait,       Target::Trait,          GenericRequirement::None;
443    DefaultTrait2,           sym::default_trait2,      default_trait2_trait,       Target::Trait,          GenericRequirement::None;
444    DefaultTrait1,           sym::default_trait1,      default_trait1_trait,       Target::Trait,          GenericRequirement::None;
445
446    ContractCheckEnsures,     sym::contract_check_ensures,      contract_check_ensures_fn,      Target::Fn, GenericRequirement::None;
447
448    // Reborrowing related lang-items
449    Reborrow,                sym::reborrow,            reborrow,                   Target::Trait,          GenericRequirement::Exact(0);
450    CoerceShared,            sym::coerce_shared,       coerce_shared,              Target::Trait,          GenericRequirement::Exact(0);
451}
452
453/// The requirement imposed on the generics of a lang item
454pub enum GenericRequirement {
455    /// No restriction on the generics
456    None,
457    /// A minimum number of generics that is demanded on a lang item
458    Minimum(usize),
459    /// The number of generics must match precisely as stipulated
460    Exact(usize),
461}
462
463pub static FN_TRAITS: &'static [LangItem] = &[LangItem::Fn, LangItem::FnMut, LangItem::FnOnce];
464
465pub static OPERATORS: &'static [LangItem] = &[
466    LangItem::Add,
467    LangItem::Sub,
468    LangItem::Mul,
469    LangItem::Div,
470    LangItem::Rem,
471    LangItem::Neg,
472    LangItem::Not,
473    LangItem::BitXor,
474    LangItem::BitAnd,
475    LangItem::BitOr,
476    LangItem::Shl,
477    LangItem::Shr,
478    LangItem::AddAssign,
479    LangItem::SubAssign,
480    LangItem::MulAssign,
481    LangItem::DivAssign,
482    LangItem::RemAssign,
483    LangItem::BitXorAssign,
484    LangItem::BitAndAssign,
485    LangItem::BitOrAssign,
486    LangItem::ShlAssign,
487    LangItem::ShrAssign,
488    LangItem::Index,
489    LangItem::IndexMut,
490    LangItem::PartialEq,
491    LangItem::PartialOrd,
492];
493
494pub static BINARY_OPERATORS: &'static [LangItem] = &[
495    LangItem::Add,
496    LangItem::Sub,
497    LangItem::Mul,
498    LangItem::Div,
499    LangItem::Rem,
500    LangItem::BitXor,
501    LangItem::BitAnd,
502    LangItem::BitOr,
503    LangItem::Shl,
504    LangItem::Shr,
505    LangItem::AddAssign,
506    LangItem::SubAssign,
507    LangItem::MulAssign,
508    LangItem::DivAssign,
509    LangItem::RemAssign,
510    LangItem::BitXorAssign,
511    LangItem::BitAndAssign,
512    LangItem::BitOrAssign,
513    LangItem::ShlAssign,
514    LangItem::ShrAssign,
515    LangItem::Index,
516    LangItem::IndexMut,
517    LangItem::PartialEq,
518    LangItem::PartialOrd,
519];