diff options
43 files changed, 277 insertions, 299 deletions
diff --git a/src/librustc_ast_lowering/lib.rs b/src/librustc_ast_lowering/lib.rs index 31eedeaed0a..586355fe613 100644 --- a/src/librustc_ast_lowering/lib.rs +++ b/src/librustc_ast_lowering/lib.rs @@ -2058,7 +2058,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { hir::GenericBound::LangItemTrait( // ::std::future::Future<future_params> - hir::LangItem::FutureTraitLangItem, + hir::LangItem::Future, span, self.next_id(), future_args, diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs index b28cb071de6..77c12c410d5 100644 --- a/src/librustc_codegen_ssa/base.rs +++ b/src/librustc_codegen_ssa/base.rs @@ -31,7 +31,7 @@ use rustc_data_structures::profiling::print_time_passes_entry; use rustc_data_structures::sync::{par_iter, Lock, ParallelIterator}; use rustc_hir as hir; use rustc_hir::def_id::{LocalDefId, LOCAL_CRATE}; -use rustc_hir::lang_items::StartFnLangItem; +use rustc_hir::lang_items::LangItem; use rustc_index::vec::Idx; use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs; use rustc_middle::middle::cstore::EncodedMetadata; @@ -458,7 +458,7 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( let (arg_argc, arg_argv) = get_argc_argv(cx, &mut bx); let (start_fn, args) = if use_start_lang_item { - let start_def_id = cx.tcx().require_lang_item(StartFnLangItem, None); + let start_def_id = cx.tcx().require_lang_item(LangItem::Start, None); let start_fn = cx.get_fn_addr( ty::Instance::resolve( cx.tcx(), diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs index a4e039de4df..8048a569f79 100644 --- a/src/librustc_codegen_ssa/mir/block.rs +++ b/src/librustc_codegen_ssa/mir/block.rs @@ -10,7 +10,7 @@ use crate::traits::*; use crate::MemFlags; use rustc_ast as ast; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_index::vec::Idx; use rustc_middle::mir; use rustc_middle::mir::interpret::{AllocId, ConstValue, Pointer, Scalar}; @@ -420,14 +420,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { let index = self.codegen_operand(&mut bx, index).immediate(); // It's `fn panic_bounds_check(index: usize, len: usize)`, // and `#[track_caller]` adds an implicit third argument. - (lang_items::PanicBoundsCheckFnLangItem, vec![index, len, location]) + (LangItem::PanicBoundsCheck, vec![index, len, location]) } _ => { let msg_str = Symbol::intern(msg.description()); let msg = bx.const_str(msg_str); // It's `pub fn panic(expr: &str)`, with the wide reference being passed // as two arguments, and `#[track_caller]` adds an implicit third argument. - (lang_items::PanicFnLangItem, vec![msg.0, msg.1, location]) + (LangItem::Panic, vec![msg.0, msg.1, location]) } }; @@ -492,8 +492,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { // Obtain the panic entry point. // FIXME: dedup this with `codegen_assert_terminator` above. - let def_id = - common::langcall(bx.tcx(), Some(span), "", lang_items::PanicFnLangItem); + let def_id = common::langcall(bx.tcx(), Some(span), "", LangItem::Panic); let instance = ty::Instance::mono(bx.tcx(), def_id); let fn_abi = FnAbi::of_instance(bx, instance, &[]); let llfn = bx.get_fn_addr(instance); diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs index 77e94fe3d0a..71f924df119 100644 --- a/src/librustc_codegen_ssa/mir/rvalue.rs +++ b/src/librustc_codegen_ssa/mir/rvalue.rs @@ -8,7 +8,7 @@ use crate::traits::*; use crate::MemFlags; use rustc_apfloat::{ieee, Float, Round, Status}; -use rustc_hir::lang_items::ExchangeMallocFnLangItem; +use rustc_hir::lang_items::LangItem; use rustc_middle::mir; use rustc_middle::ty::cast::{CastTy, IntTy}; use rustc_middle::ty::layout::{HasTyCtxt, TyAndLayout}; @@ -507,7 +507,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { let llty_ptr = bx.cx().backend_type(box_layout); // Allocate space: - let def_id = match bx.tcx().lang_items().require(ExchangeMallocFnLangItem) { + let def_id = match bx.tcx().lang_items().require(LangItem::ExchangeMalloc) { Ok(id) => id, Err(s) => { bx.cx().sess().fatal(&format!("allocation of `{}` {}", box_layout.ty, s)); diff --git a/src/librustc_hir/lang_items.rs b/src/librustc_hir/lang_items.rs index 978f73760ec..acf6847c014 100644 --- a/src/librustc_hir/lang_items.rs +++ b/src/librustc_hir/lang_items.rs @@ -7,8 +7,6 @@ //! * Traits that represent operators; e.g., `Add`, `Sub`, `Index`. //! * Functions called by the compiler itself. -pub use self::LangItem::*; - use crate::def_id::DefId; use crate::{MethodKind, Target}; @@ -57,14 +55,14 @@ macro_rules! language_item_table { /// that is `#[lang = "eq"]` would result in `sym::eq`. pub fn name(self) -> Symbol { match self { - $( $variant => $name, )* + $( LangItem::$variant => $name, )* } } pub fn group(self) -> Option<LangItemGroup> { use LangItemGroup::*; match self { - $( $variant => expand_group!($($group)*), )* + $( LangItem::$variant => expand_group!($($group)*), )* } } } @@ -87,7 +85,7 @@ macro_rules! language_item_table { fn init_none(_: LangItem) -> Option<DefId> { None } Self { - items: vec![$(init_none($variant)),*], + items: vec![$(init_none(LangItem::$variant)),*], missing: Vec::new(), groups: [vec![]; NUM_GROUPS], } @@ -114,7 +112,7 @@ macro_rules! language_item_table { /// exists. #[allow(dead_code)] pub fn $method(&self) -> Option<DefId> { - self.items[$variant as usize] + self.items[LangItem::$variant as usize] } )* } @@ -123,7 +121,7 @@ macro_rules! language_item_table { /// A mapping from the name of the lang item to its order and the form it must be of. pub static ref ITEM_REFS: FxHashMap<Symbol, (usize, Target)> = { let mut item_refs = FxHashMap::default(); - $( item_refs.insert($name, ($variant as usize, $target)); )* + $( item_refs.insert($name, (LangItem::$variant as usize, $target)); )* item_refs }; } @@ -161,179 +159,176 @@ where } language_item_table! { -// Variant name, Name, Method name, Target; - BoolImplItem, sym::bool, bool_impl, Target::Impl; - CharImplItem, sym::char, char_impl, Target::Impl; - StrImplItem, sym::str, str_impl, Target::Impl; - ArrayImplItem, sym::array, array_impl, Target::Impl; - SliceImplItem, sym::slice, slice_impl, Target::Impl; - SliceU8ImplItem, sym::slice_u8, slice_u8_impl, Target::Impl; - StrAllocImplItem, sym::str_alloc, str_alloc_impl, Target::Impl; - SliceAllocImplItem, sym::slice_alloc, slice_alloc_impl, Target::Impl; - SliceU8AllocImplItem, sym::slice_u8_alloc, slice_u8_alloc_impl, Target::Impl; - ConstPtrImplItem, sym::const_ptr, const_ptr_impl, Target::Impl; - MutPtrImplItem, sym::mut_ptr, mut_ptr_impl, Target::Impl; - ConstSlicePtrImplItem, sym::const_slice_ptr, const_slice_ptr_impl, Target::Impl; - MutSlicePtrImplItem, sym::mut_slice_ptr, mut_slice_ptr_impl, Target::Impl; - I8ImplItem, sym::i8, i8_impl, Target::Impl; - I16ImplItem, sym::i16, i16_impl, Target::Impl; - I32ImplItem, sym::i32, i32_impl, Target::Impl; - I64ImplItem, sym::i64, i64_impl, Target::Impl; - I128ImplItem, sym::i128, i128_impl, Target::Impl; - IsizeImplItem, sym::isize, isize_impl, Target::Impl; - U8ImplItem, sym::u8, u8_impl, Target::Impl; - U16ImplItem, sym::u16, u16_impl, Target::Impl; - U32ImplItem, sym::u32, u32_impl, Target::Impl; - U64ImplItem, sym::u64, u64_impl, Target::Impl; - U128ImplItem, sym::u128, u128_impl, Target::Impl; - UsizeImplItem, sym::usize, usize_impl, Target::Impl; - F32ImplItem, sym::f32, f32_impl, Target::Impl; - F64ImplItem, sym::f64, f64_impl, Target::Impl; - F32RuntimeImplItem, sym::f32_runtime, f32_runtime_impl, Target::Impl; - F64RuntimeImplItem, sym::f64_runtime, f64_runtime_impl, Target::Impl; - - SizedTraitLangItem, sym::sized, sized_trait, Target::Trait; - UnsizeTraitLangItem, sym::unsize, unsize_trait, Target::Trait; - // trait injected by #[derive(PartialEq)], (i.e. "Partial EQ"). - StructuralPeqTraitLangItem, sym::structural_peq, structural_peq_trait, Target::Trait; - // trait injected by #[derive(Eq)], (i.e. "Total EQ"; no, I will not apologize). - StructuralTeqTraitLangItem, sym::structural_teq, structural_teq_trait, Target::Trait; - CopyTraitLangItem, sym::copy, copy_trait, Target::Trait; - CloneTraitLangItem, sym::clone, clone_trait, Target::Trait; - SyncTraitLangItem, sym::sync, sync_trait, Target::Trait; - DiscriminantKindTraitLangItem, sym::discriminant_kind, discriminant_kind_trait, Target::Trait; +// Variant name, Name, Method name, Target; + Bool, sym::bool, bool_impl, Target::Impl; + Char, sym::char, char_impl, Target::Impl; + Str, sym::str, str_impl, Target::Impl; + Array, sym::array, array_impl, Target::Impl; + Slice, sym::slice, slice_impl, Target::Impl; + SliceU8, sym::slice_u8, slice_u8_impl, Target::Impl; + StrAlloc, sym::str_alloc, str_alloc_impl, Target::Impl; + SliceAlloc, sym::slice_alloc, slice_alloc_impl, Target::Impl; + SliceU8Alloc, sym::slice_u8_alloc, slice_u8_alloc_impl, Target::Impl; + ConstPtr, sym::const_ptr, const_ptr_impl, Target::Impl; + MutPtr, sym::mut_ptr, mut_ptr_impl, Target::Impl; + ConstSlicePtr, sym::const_slice_ptr, const_slice_ptr_impl, Target::Impl; + MutSlicePtr, sym::mut_slice_ptr, mut_slice_ptr_impl, Target::Impl; + I8, sym::i8, i8_impl, Target::Impl; + I16, sym::i16, i16_impl, Target::Impl; + I32, sym::i32, i32_impl, Target::Impl; + I64, sym::i64, i64_impl, Target::Impl; + I128, sym::i128, i128_impl, Target::Impl; + Isize, sym::isize, isize_impl, Target::Impl; + U8, sym::u8, u8_impl, Target::Impl; + U16, sym::u16, u16_impl, Target::Impl; + U32, sym::u32, u32_impl, Target::Impl; + U64, sym::u64, u64_impl, Target::Impl; + U128, sym::u128, u128_impl, Target::Impl; + Usize, sym::usize, usize_impl, Target::Impl; + F32, sym::f32, f32_impl, Target::Impl; + F64, sym::f64, f64_impl, Target::Impl; + F32Runtime, sym::f32_runtime, f32_runtime_impl, Target::Impl; + F64Runtime, sym::f64_runtime, f64_runtime_impl, Target::Impl; + + Sized, sym::sized, sized_trait, Target::Trait; + Unsize, sym::unsize, unsize_trait, Target::Trait; + // Trait injected by #[derive(PartialEq)], (i.e. "Partial EQ"). + StructuralPeq, sym::structural_peq, structural_peq_trait, Target::Trait; + // Trait injected by #[derive(Eq)], (i.e. "Total EQ"; no, I will not apologize). + StructuralTeq, sym::structural_teq, structural_teq_trait, Target::Trait; + Copy, sym::copy, copy_trait, Target::Trait; + Clone, sym::clone, clone_trait, Target::Trait; + Sync, sym::sync, sync_trait, Target::Trait; + DiscriminantKind, sym::discriminant_kind, discriminant_kind_trait, Target::Trait; // The associated item of `trait DiscriminantKind`. - DiscriminantTypeLangItem, sym::discriminant_type, discriminant_type, Target::AssocTy; - - FreezeTraitLangItem, sym::freeze, freeze_trait, Target::Trait; - - DropTraitLangItem, sym::drop, drop_trait, Target::Trait; - - CoerceUnsizedTraitLangItem, sym::coerce_unsized, coerce_unsized_trait, Target::Trait; - DispatchFromDynTraitLangItem, sym::dispatch_from_dyn, dispatch_from_dyn_trait, Target::Trait; - - AddTraitLangItem(Op), sym::add, add_trait, Target::Trait; - SubTraitLangItem(Op), sym::sub, sub_trait, Target::Trait; - MulTraitLangItem(Op), sym::mul, mul_trait, Target::Trait; - DivTraitLangItem(Op), sym::div, div_trait, Target::Trait; - RemTraitLangItem(Op), sym::rem, rem_trait, Target::Trait; - NegTraitLangItem(Op), sym::neg, neg_trait, Target::Trait; - NotTraitLangItem(Op), sym::not, not_trait, Target::Trait; - BitXorTraitLangItem(Op), sym::bitxor, bitxor_trait, Target::Trait; - BitAndTraitLangItem(Op), sym::bitand, bitand_trait, Target::Trait; - BitOrTraitLangItem(Op), sym::bitor, bitor_trait, Target::Trait; - ShlTraitLangItem(Op), sym::shl, shl_trait, Target::Trait; - ShrTraitLangItem(Op), sym::shr, shr_trait, Target::Trait; - AddAssignTraitLangItem(Op), sym::add_assign, add_assign_trait, Target::Trait; - SubAssignTraitLangItem(Op), sym::sub_assign, sub_assign_trait, Target::Trait; - MulAssignTraitLangItem(Op), sym::mul_assign, mul_assign_trait, Target::Trait; - DivAssignTraitLangItem(Op), sym::div_assign, div_assign_trait, Target::Trait; - RemAssignTraitLangItem(Op), sym::rem_assign, rem_assign_trait, Target::Trait; - BitXorAssignTraitLangItem(Op), sym::bitxor_assign, bitxor_assign_trait, Target::Trait; - BitAndAssignTraitLangItem(Op), sym::bitand_assign, bitand_assign_trait, Target::Trait; - BitOrAssignTraitLangItem(Op), sym::bitor_assign, bitor_assign_trait, Target::Trait; - ShlAssignTraitLangItem(Op), sym::shl_assign, shl_assign_trait, Target::Trait; - ShrAssignTraitLangItem(Op), sym::shr_assign, shr_assign_trait, Target::Trait; - IndexTraitLangItem(Op), sym::index, index_trait, Target::Trait; - IndexMutTraitLangItem(Op), sym::index_mut, index_mut_trait, Target::Trait; - - UnsafeCellTypeLangItem, sym::unsafe_cell, unsafe_cell_type, Target::Struct; - VaListTypeLangItem, sym::va_list, va_list, Target::Struct; - - DerefTraitLangItem, sym::deref, deref_trait, Target::Trait; - DerefMutTraitLangItem, sym::deref_mut, deref_mut_trait, Target::Trait; - ReceiverTraitLangItem, sym::receiver, receiver_trait, Target::Trait; - - FnTraitLangItem, kw::Fn, fn_trait, Target::Trait; - FnMutTraitLangItem, sym::fn_mut, fn_mut_trait, Target::Trait; - FnOnceTraitLangItem, sym::fn_once, fn_once_trait, Target::Trait; - - FnOnceOutputLangItem, sym::fn_once_output, fn_once_output, Target::AssocTy; - - FutureTraitLangItem, sym::future_trait, future_trait, Target::Trait; - GeneratorStateLangItem, sym::generator_state, gen_state, Target::Enum; - GeneratorTraitLangItem, sym::generator, gen_trait, Target::Trait; - UnpinTraitLangItem, sym::unpin, unpin_trait, Target::Trait; - PinTypeLangItem, sym::pin, pin_type, Target::Struct; - - // Don't be fooled by the naming here: this lang item denotes `PartialEq`, not `Eq`. - EqTraitLangItem, sym::eq, eq_trait, Target::Trait; - PartialOrdTraitLangItem, sym::partial_ord, partial_ord_trait, Target::Trait; - - // A number of panic-related lang items. The `panic` item corresponds to - // divide-by-zero and various panic cases with `match`. The - // `panic_bounds_check` item is for indexing arrays. + Discriminant, sym::discriminant_type, discriminant_type, Target::AssocTy; + + Freeze, sym::freeze, freeze_trait, Target::Trait; + + Drop, sym::drop, drop_trait, Target::Trait; + + CoerceUnsized, sym::coerce_unsized, coerce_unsized_trait, Target::Trait; + DispatchFromDyn, sym::dispatch_from_dyn, dispatch_from_dyn_trait, Target::Trait; + + Add(Op), sym::add, add_trait, Target::Trait; + Sub(Op), sym::sub, sub_trait, Target::Trait; + Mul(Op), sym::mul, mul_trait, Target::Trait; + Div(Op), sym::div, div_trait, Target::Trait; + Rem(Op), sym::rem, rem_trait, Target::Trait; + Neg(Op), sym::neg, neg_trait, Target::Trait; + Not(Op), sym::not, not_trait, Target::Trait; + BitXor(Op), sym::bitxor, bitxor_trait, Target::Trait; + BitAnd(Op), sym::bitand, bitand_trait, Target::Trait; + BitOr(Op), sym::bitor, bitor_trait, Target::Trait; + Shl(Op), sym::shl, shl_trait, Target::Trait; + Shr(Op), sym::shr, shr_trait, Target::Trait; + AddAssign(Op), sym::add_assign, add_assign_trait, Target::Trait; + SubAssign(Op), sym::sub_assign, sub_assign_trait, Target::Trait; + MulAssign(Op), sym::mul_assign, mul_assign_trait, Target::Trait; + DivAssign(Op), sym::div_assign, div_assign_trait, Target::Trait; + RemAssign(Op), sym::rem_assign, rem_assign_trait, Target::Trait; + BitXorAssign(Op), sym::bitxor_assign, bitxor_assign_trait, Target::Trait; + BitAndAssign(Op), sym::bitand_assign, bitand_assign_trait, Target::Trait; + BitOrAssign(Op), sym::bitor_assign, bitor_assign_trait, Target::Trait; + ShlAssign(Op), sym::shl_assign, shl_assign_trait, Target::Trait; + ShrAssign(Op), sym::shr_assign, shr_assign_trait, Target::Trait; + Index(Op), sym::index, index_trait, Target::Trait; + IndexMut(Op), sym::index_mut, index_mut_trait, Target::Trait; + + UnsafeCell, sym::unsafe_cell, unsafe_cell_type, Target::Struct; + VaList, sym::va_list, va_list, Target::Struct; + + Deref, sym::deref, deref_trait, Target::Trait; + DerefMut, sym::deref_mut, deref_mut_trait, Target::Trait; + Receiver, sym::receiver, receiver_trait, Target::Trait; + + Fn, kw::Fn, fn_trait, Target::Trait; + FnMut, sym::fn_mut, fn_mut_trait, Target::Trait; + FnOnce, sym::fn_once, fn_once_trait, Target::Trait; + + FnOnceOutput, sym::fn_once_output, fn_once_output, Target::AssocTy; + + Future, sym::future_trait, future_trait, Target::Trait; + GeneratorState, sym::generator_state, gen_state, Target::Enum; + Generator, sym::generator, gen_trait, Target::Trait; + Unpin, sym::unpin, unpin_trait, Target::Trait; + Pin, sym::pin, pin_type, Target::Struct; + + PartialEq, sym::eq, eq_trait, Target::Trait; + PartialOrd, sym::partial_ord, partial_ord_trait, Target::Trait; + + // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and + // various panic cases with `match`. The `panic_bounds_check` item is for indexing arrays. // - // The `begin_unwind` lang item has a predefined symbol name and is sort of - // a "weak lang item" in the sense that a crate is not required to have it - // defined to use it, but a final product is required to define it - // somewhere. Additionally, there are restrictions on crates that use a weak - // lang item, but do not have it defined. - PanicFnLangItem, sym::panic, panic_fn, Target::Fn; - PanicBoundsCheckFnLangItem, sym::panic_bounds_check, panic_bounds_check_fn, Target::Fn; - PanicInfoLangItem, sym::panic_info, panic_info, Target::Struct; - PanicLocationLangItem, sym::panic_location, panic_location, Target::Struct; - PanicImplLangItem, sym::panic_impl, panic_impl, Target::Fn; - // Libstd panic entry point. Necessary for const eval to be able to catch it - BeginPanicFnLangItem, sym::begin_panic, begin_panic_fn, Target::Fn; + // The `begin_unwind` lang item has a predefined symbol name and is sort of a "weak lang item" + // in the sense that a crate is not required to have it defined to use it, but a final product + // is required to define it somewhere. Additionally, there are restrictions on crates that use + // a weak lang item, but do not have it defined. + Panic, sym::panic, panic_fn, Target::Fn; + PanicBoundsCheck, sym::panic_bounds_check, panic_bounds_check_fn, Target::Fn; + PanicInfo, sym::panic_info, panic_info, Target::Struct; + PanicLocation, sym::panic_location, panic_location, Target::Struct; + PanicImpl, sym::panic_impl, panic_impl, Target::Fn; + // libstd panic entry point. Necessary for const eval to be able to catch it + BeginPanic, sym::begin_panic, begin_panic_fn, Target::Fn; - ExchangeMallocFnLangItem, sym::exchange_malloc, exchange_malloc_fn, Target::Fn; - BoxFreeFnLangItem, sym::box_free, box_free_fn, Target::Fn; - DropInPlaceFnLangItem, sym::drop_in_place, drop_in_place_fn, Target::Fn; - OomLangItem, sym::oom, oom, Target::Fn; - AllocLayoutLangItem, sym::alloc_layout, alloc_layout, Target::Struct; + ExchangeMalloc, sym::exchange_malloc, exchange_malloc_fn, Target::Fn; + BoxFree, sym::box_free, box_free_fn, Target::Fn; + DropInPlace, sym::drop_in_place, drop_in_place_fn, Target::Fn; + Oom, sym::oom, oom, Target::Fn; + AllocLayout, sym::alloc_layout, alloc_layout, Target::Struct; - StartFnLangItem, sym::start, start_fn, Target::Fn; + Start, sym::start, start_fn, Target::Fn; - EhPersonalityLangItem, sym::eh_personality, eh_personality, Target::Fn; - EhCatchTypeinfoLangItem, sym::eh_catch_typeinfo, eh_catch_typeinfo, Target::Static; + EhPersonality, sym::eh_personality, eh_personality, Target::Fn; + EhCatchTypeinfo, sym::eh_catch_typeinfo, eh_catch_typeinfo, Target::Static; - OwnedBoxLangItem, sym::owned_box, owned_box, Target::Struct; + OwnedBox, sym::owned_box, owned_box, Target::Struct; - PhantomDataItem, sym::phantom_data, phantom_data, Target::Struct; + PhantomData, sym::phantom_data, phantom_data, Target::Struct; - ManuallyDropItem, sym::manually_drop, manually_drop, Target::Struct; + ManuallyDrop, sym::manually_drop, manually_drop, Target::Struct; - MaybeUninitLangItem, sym::maybe_uninit, maybe_uninit, Target::Union; + MaybeUninit, sym::maybe_uninit, maybe_uninit, Target::Union; // Align offset for stride != 1; must not panic. - AlignOffsetLangItem, sym::align_offset, align_offset_fn, Target::Fn; + AlignOffset, sym::align_offset, align_offset_fn, Target::Fn; - TerminationTraitLangItem, sym::termination, termination, Target::Trait; + Termination, sym::termination, termination, Target::Trait; - TryTraitLangItem, kw::Try, try_trait, Target::Trait; + Try, kw::Try, try_trait, Target::Trait; // Language items from AST lowering - TryFromError, sym::from_error, from_error_fn, Target::Method(MethodKind::Trait { body: false }); - TryFromOk, sym::from_ok, from_ok_fn, Target::Method(MethodKind::Trait { body: false }); - TryIntoResult, sym::into_result, into_result_fn, Target::Method(MethodKind::Trait { body: false }); + TryFromError, sym::from_error, from_error_fn, Target::Method(MethodKind::Trait { body: false }); + TryFromOk, sym::from_ok, from_ok_fn, Target::Method(MethodKind::Trait { body: false }); + TryIntoResult, sym::into_result, into_result_fn, Target::Method(MethodKind::Trait { body: false }); - PollReady, sym::Ready, poll_ready_variant, Target::Variant; - PollPending, sym::Pending, poll_pending_variant, Target::Variant; + PollReady, sym::Ready, poll_ready_variant, Target::Variant; + PollPending, sym::Pending, poll_pending_variant, Target::Variant; - FromGenerator, sym::from_generator, from_generator_fn, Target::Fn; - GetContext, sym::get_context, get_context_fn, Target::Fn; + FromGenerator, sym::from_generator, from_generator_fn, Target::Fn; + GetContext, sym::get_context, get_context_fn, Target::Fn; - FuturePoll, sym::poll, future_poll_fn, Target::Method(MethodKind::Trait { body: false }); + FuturePoll, sym::poll, future_poll_fn, Target::Method(MethodKind::Trait { body: false }); - FromFrom, sym::from, from_fn, Target::Method(MethodKind::Trait { body: false }); + FromFrom, sym::from, from_fn, Target::Method(MethodKind::Trait { body: false }); - OptionSome, sym::Some, option_some_variant, Target::Variant; - OptionNone, sym::None, option_none_variant, Target::Variant; + OptionSome, sym::Some, option_some_variant, Target::Variant; + OptionNone, sym::None, option_none_variant, Target::Variant; - ResultOk, sym::Ok, result_ok_variant, Target::Variant; - ResultErr, sym::Err, result_err_variant, Target::Variant; + ResultOk, sym::Ok, result_ok_variant, Target::Variant; + ResultErr, sym::Err, result_err_variant, Target::Variant; - IntoIterIntoIter, sym::into_iter, into_iter_fn, Target::Method(MethodKind::Trait { body: false }); - IteratorNext, sym::next, next_fn, Target::Method(MethodKind::Trait { body: false}); + IntoIterIntoIter, sym::into_iter, into_iter_fn, Target::Method(MethodKind::Trait { body: false }); + IteratorNext, sym::next, next_fn, Target::Method(MethodKind::Trait { body: false}); - PinNewUnchecked, sym::new_unchecked, new_unchecked_fn, Target::Method(MethodKind::Inherent); + PinNewUnchecked, sym::new_unchecked, new_unchecked_fn, Target::Method(MethodKind::Inherent); - RangeFrom, sym::RangeFrom, range_from_struct, Target::Struct; - RangeFull, sym::RangeFull, range_full_struct, Target::Struct; - RangeInclusiveStruct, sym::RangeInclusive, range_inclusive_struct, Target::Struct; - RangeInclusiveNew, sym::range_inclusive_new, range_inclusive_new_method, Target::Method(MethodKind::Inherent); - Range, sym::Range, range_struct, Target::Struct; - RangeToInclusive, sym::RangeToInclusive, range_to_inclusive_struct, Target::Struct; - RangeTo, sym::RangeTo, range_to_struct, Target::Struct; + RangeFrom, sym::RangeFrom, range_from_struct, Target::Struct; + RangeFull, sym::RangeFull, range_full_struct, Target::Struct; + RangeInclusiveStruct, sym::RangeInclusive, range_inclusive_struct, Target::Struct; + RangeInclusiveNew, sym::range_inclusive_new, range_inclusive_new_method, Target::Method(MethodKind::Inherent); + Range, sym::Range, range_struct, Target::Struct; + RangeToInclusive, sym::RangeToInclusive, range_to_inclusive_struct, Target::Struct; + RangeTo, sym::RangeTo, range_to_struct, Target::Struct; } diff --git a/src/librustc_hir/weak_lang_items.rs b/src/librustc_hir/weak_lang_items.rs index 76b95c696f7..74e2a90262c 100644 --- a/src/librustc_hir/weak_lang_items.rs +++ b/src/librustc_hir/weak_lang_items.rs @@ -15,7 +15,7 @@ macro_rules! weak_lang_items { lazy_static! { pub static ref WEAK_ITEMS_REFS: FxHashMap<Symbol, LangItem> = { let mut map = FxHashMap::default(); - $(map.insert(sym::$name, lang_items::$item);)* + $(map.insert(sym::$name, LangItem::$item);)* map }; } @@ -46,7 +46,7 @@ impl LanguageItems { ) } weak_lang_items! { - panic_impl, PanicImplLangItem, rust_begin_unwind; - eh_personality, EhPersonalityLangItem, rust_eh_personality; - oom, OomLangItem, rust_oom; + panic_impl, PanicImpl, rust_begin_unwind; + eh_personality, EhPersonality, rust_eh_personality; + oom, Oom, rust_oom; } diff --git a/src/librustc_middle/middle/lang_items.rs b/src/librustc_middle/middle/lang_items.rs index 70c90198276..3e1caa3b549 100644 --- a/src/librustc_middle/middle/lang_items.rs +++ b/src/librustc_middle/middle/lang_items.rs @@ -53,7 +53,7 @@ pub fn required(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool { // symbols. Other panic runtimes ensure that the relevant symbols are // available to link things together, but they're never exercised. match tcx.sess.panic_strategy() { - PanicStrategy::Abort => lang_item != LangItem::EhPersonalityLangItem, + PanicStrategy::Abort => lang_item != LangItem::EhPersonality, PanicStrategy::Unwind => true, } } diff --git a/src/librustc_middle/ty/adjustment.rs b/src/librustc_middle/ty/adjustment.rs index 0ab07aea426..6a9bb8d6c28 100644 --- a/src/librustc_middle/ty/adjustment.rs +++ b/src/librustc_middle/ty/adjustment.rs @@ -2,7 +2,7 @@ use crate::ty::subst::SubstsRef; use crate::ty::{self, Ty, TyCtxt}; use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items::{DerefMutTraitLangItem, DerefTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_macros::HashStable; #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] @@ -118,8 +118,8 @@ pub struct OverloadedDeref<'tcx> { impl<'tcx> OverloadedDeref<'tcx> { pub fn method_call(&self, tcx: TyCtxt<'tcx>, source: Ty<'tcx>) -> (DefId, SubstsRef<'tcx>) { let trait_def_id = match self.mutbl { - hir::Mutability::Not => tcx.require_lang_item(DerefTraitLangItem, None), - hir::Mutability::Mut => tcx.require_lang_item(DerefMutTraitLangItem, None), + hir::Mutability::Not => tcx.require_lang_item(LangItem::Deref, None), + hir::Mutability::Mut => tcx.require_lang_item(LangItem::DerefMut, None), }; let method_def_id = tcx .associated_items(trait_def_id) diff --git a/src/librustc_middle/ty/context.rs b/src/librustc_middle/ty/context.rs index d1fd65fc244..18ae744cb1e 100644 --- a/src/librustc_middle/ty/context.rs +++ b/src/librustc_middle/ty/context.rs @@ -40,7 +40,7 @@ use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LOCAL_CRATE}; use rustc_hir::definitions::{DefPathHash, Definitions}; use rustc_hir::intravisit::Visitor; -use rustc_hir::lang_items::{self, PanicLocationLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_hir::{HirId, ItemKind, ItemLocalId, ItemLocalMap, ItemLocalSet, Node, TraitCandidate}; use rustc_index::vec::{Idx, IndexVec}; use rustc_macros::HashStable; @@ -1538,7 +1538,7 @@ impl<'tcx> TyCtxt<'tcx> { pub fn caller_location_ty(&self) -> Ty<'tcx> { self.mk_imm_ref( self.lifetimes.re_static, - self.type_of(self.require_lang_item(PanicLocationLangItem, None)) + self.type_of(self.require_lang_item(LangItem::PanicLocation, None)) .subst(*self, self.mk_substs([self.lifetimes.re_static.into()].iter())), ) } @@ -2185,12 +2185,12 @@ impl<'tcx> TyCtxt<'tcx> { #[inline] pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> { - let def_id = self.require_lang_item(lang_items::OwnedBoxLangItem, None); + let def_id = self.require_lang_item(LangItem::OwnedBox, None); self.mk_generic_adt(def_id, ty) } #[inline] - pub fn mk_lang_item(self, ty: Ty<'tcx>, item: lang_items::LangItem) -> Option<Ty<'tcx>> { + pub fn mk_lang_item(self, ty: Ty<'tcx>, item: LangItem) -> Option<Ty<'tcx>> { let def_id = self.lang_items().require(item).ok()?; Some(self.mk_generic_adt(def_id, ty)) } @@ -2203,7 +2203,7 @@ impl<'tcx> TyCtxt<'tcx> { #[inline] pub fn mk_maybe_uninit(self, ty: Ty<'tcx>) -> Ty<'tcx> { - let def_id = self.require_lang_item(lang_items::MaybeUninitLangItem, None); + let def_id = self.require_lang_item(LangItem::MaybeUninit, None); self.mk_generic_adt(def_id, ty) } diff --git a/src/librustc_middle/ty/instance.rs b/src/librustc_middle/ty/instance.rs index e6dafd4965b..8e08fe4b87b 100644 --- a/src/librustc_middle/ty/instance.rs +++ b/src/librustc_middle/ty/instance.rs @@ -5,7 +5,7 @@ use crate::ty::{self, SubstsRef, Ty, TyCtxt, TypeFoldable}; use rustc_errors::ErrorReported; use rustc_hir::def::Namespace; use rustc_hir::def_id::{CrateNum, DefId}; -use rustc_hir::lang_items::{DropInPlaceFnLangItem, FnOnceTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_macros::HashStable; use std::fmt; @@ -408,7 +408,7 @@ impl<'tcx> Instance<'tcx> { } pub fn resolve_drop_in_place(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ty::Instance<'tcx> { - let def_id = tcx.require_lang_item(DropInPlaceFnLangItem, None); + let def_id = tcx.require_lang_item(LangItem::DropInPlace, None); let substs = tcx.intern_substs(&[ty.into()]); Instance::resolve(tcx, ty::ParamEnv::reveal_all(), def_id, substs).unwrap().unwrap() } @@ -419,7 +419,7 @@ impl<'tcx> Instance<'tcx> { substs: ty::SubstsRef<'tcx>, ) -> Instance<'tcx> { debug!("fn_once_adapter_shim({:?}, {:?})", closure_did, substs); - let fn_once = tcx.require_lang_item(FnOnceTraitLangItem, None); + let fn_once = tcx.require_lang_item(LangItem::FnOnce, None); let call_once = tcx .associated_items(fn_once) .in_definition_order() diff --git a/src/librustc_middle/ty/layout.rs b/src/librustc_middle/ty/layout.rs index 928cba324d5..08bd131565b 100644 --- a/src/librustc_middle/ty/layout.rs +++ b/src/librustc_middle/ty/layout.rs @@ -8,7 +8,7 @@ use rustc_ast::{self as ast, IntTy, UintTy}; use rustc_attr as attr; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_hir as hir; -use rustc_hir::lang_items::{GeneratorStateLangItem, PinTypeLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_index::bit_set::BitSet; use rustc_index::vec::{Idx, IndexVec}; use rustc_session::{DataTypeKind, FieldInfo, SizeKind, VariantInfo}; @@ -2371,13 +2371,13 @@ impl<'tcx> ty::Instance<'tcx> { let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv); let env_ty = tcx.mk_mut_ref(tcx.mk_region(env_region), ty); - let pin_did = tcx.require_lang_item(PinTypeLangItem, None); + let pin_did = tcx.require_lang_item(LangItem::Pin, None); let pin_adt_ref = tcx.adt_def(pin_did); let pin_substs = tcx.intern_substs(&[env_ty.into()]); let env_ty = tcx.mk_adt(pin_adt_ref, pin_substs); sig.map_bound(|sig| { - let state_did = tcx.require_lang_item(GeneratorStateLangItem, None); + let state_did = tcx.require_lang_item(LangItem::GeneratorState, None); let state_adt_ref = tcx.adt_def(state_did); let state_substs = tcx.intern_substs(&[sig.yield_ty.into(), sig.return_ty.into()]); diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs index 4fa86a91254..a961d02f7a2 100644 --- a/src/librustc_middle/ty/mod.rs +++ b/src/librustc_middle/ty/mod.rs @@ -32,7 +32,7 @@ use rustc_errors::ErrorReported; use rustc_hir as hir; use rustc_hir::def::{CtorKind, CtorOf, DefKind, Namespace, Res}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX}; -use rustc_hir::lang_items::{FnMutTraitLangItem, FnOnceTraitLangItem, FnTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_hir::{Constness, Node}; use rustc_index::vec::{Idx, IndexVec}; use rustc_macros::HashStable; @@ -2670,9 +2670,9 @@ impl<'tcx> ClosureKind { pub fn trait_did(&self, tcx: TyCtxt<'tcx>) -> DefId { match *self { - ClosureKind::Fn => tcx.require_lang_item(FnTraitLangItem, None), - ClosureKind::FnMut => tcx.require_lang_item(FnMutTraitLangItem, None), - ClosureKind::FnOnce => tcx.require_lang_item(FnOnceTraitLangItem, None), + ClosureKind::Fn => tcx.require_lang_item(LangItem::Fn, None), + ClosureKind::FnMut => tcx.require_lang_item(LangItem::FnMut, None), + ClosureKind::FnOnce => tcx.require_lang_item(LangItem::FnOnce, None), } } diff --git a/src/librustc_mir/borrow_check/type_check/mod.rs b/src/librustc_mir/borrow_check/type_check/mod.rs index 168a352591d..b95d963759a 100644 --- a/src/librustc_mir/borrow_check/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/type_check/mod.rs @@ -10,7 +10,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_hir::lang_items::{CoerceUnsizedTraitLangItem, CopyTraitLangItem, SizedTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_index::vec::{Idx, IndexVec}; use rustc_infer::infer::canonical::QueryRegionConstraints; use rustc_infer::infer::outlives::env::RegionBoundPairs; @@ -507,7 +507,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> { if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context { let tcx = self.tcx(); let trait_ref = ty::TraitRef { - def_id: tcx.require_lang_item(CopyTraitLangItem, Some(self.last_span)), + def_id: tcx.require_lang_item(LangItem::Copy, Some(self.last_span)), substs: tcx.mk_substs_trait(place_ty.ty, &[]), }; @@ -1474,7 +1474,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { self.check_rvalue(body, rv, location); if !self.tcx().features().unsized_locals { let trait_ref = ty::TraitRef { - def_id: tcx.require_lang_item(SizedTraitLangItem, Some(self.last_span)), + def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)), substs: tcx.mk_substs_trait(place_ty, &[]), }; self.prove_trait_ref( @@ -2025,7 +2025,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { self.param_env, ty::Binder::bind(ty::TraitRef::new( self.tcx().require_lang_item( - CopyTraitLangItem, + LangItem::Copy, Some(self.last_span), ), tcx.mk_substs_trait(ty, &[]), @@ -2050,7 +2050,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { } let trait_ref = ty::TraitRef { - def_id: tcx.require_lang_item(SizedTraitLangItem, Some(self.last_span)), + def_id: tcx.require_lang_item(LangItem::Sized, Some(self.last_span)), substs: tcx.mk_substs_trait(ty, &[]), }; @@ -2148,10 +2148,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { CastKind::Pointer(PointerCast::Unsize) => { let &ty = ty; let trait_ref = ty::TraitRef { - def_id: tcx.require_lang_item( - CoerceUnsizedTraitLangItem, - Some(self.last_span), - ), + def_id: tcx + .require_lang_item(LangItem::CoerceUnsized, Some(self.last_span)), substs: tcx.mk_substs_trait(op.ty(body, tcx), &[ty.into()]), }; diff --git a/src/librustc_mir/borrow_check/universal_regions.rs b/src/librustc_mir/borrow_check/universal_regions.rs index cd6b75cf556..9dfc67bcf67 100644 --- a/src/librustc_mir/borrow_check/universal_regions.rs +++ b/src/librustc_mir/borrow_check/universal_regions.rs @@ -17,7 +17,7 @@ use rustc_data_structures::fx::FxHashMap; use rustc_errors::DiagnosticBuilder; use rustc_hir as hir; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_hir::{BodyOwnerKind, HirId}; use rustc_index::vec::{Idx, IndexVec}; use rustc_infer::infer::{InferCtxt, NLLRegionVariableOrigin}; @@ -456,7 +456,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> { if let DefiningTy::FnDef(def_id, _) = defining_ty { if self.infcx.tcx.fn_sig(def_id).c_variadic() { let va_list_did = self.infcx.tcx.require_lang_item( - lang_items::VaListTypeLangItem, + LangItem::VaList, Some(self.infcx.tcx.def_span(self.mir_def.did)), ); let region = self diff --git a/src/librustc_mir/interpret/intrinsics/caller_location.rs b/src/librustc_mir/interpret/intrinsics/caller_location.rs index fb3a670714b..d9be28cf9db 100644 --- a/src/librustc_mir/interpret/intrinsics/caller_location.rs +++ b/src/librustc_mir/interpret/intrinsics/caller_location.rs @@ -1,6 +1,6 @@ use std::convert::TryFrom; -use rustc_hir::lang_items::PanicLocationLangItem; +use rustc_hir::lang_items::LangItem; use rustc_middle::mir::TerminatorKind; use rustc_middle::ty::subst::Subst; use rustc_span::{Span, Symbol}; @@ -63,7 +63,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // Allocate memory for `CallerLocation` struct. let loc_ty = self .tcx - .type_of(self.tcx.require_lang_item(PanicLocationLangItem, None)) + .type_of(self.tcx.require_lang_item(LangItem::PanicLocation, None)) .subst(*self.tcx, self.tcx.mk_substs([self.tcx.lifetimes.re_erased.into()].iter())); let loc_layout = self.layout_of(loc_ty).unwrap(); let location = self.allocate(loc_layout, MemoryKind::CallerLocation); diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index e724180f4d8..d379f4ef428 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -182,7 +182,7 @@ use rustc_errors::{ErrorReported, FatalError}; use rustc_hir as hir; use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, LOCAL_CRATE}; use rustc_hir::itemlikevisit::ItemLikeVisitor; -use rustc_hir::lang_items::{ExchangeMallocFnLangItem, StartFnLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_index::bit_set::GrowableBitSet; use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; use rustc_middle::mir::interpret::{AllocId, ConstValue}; @@ -594,7 +594,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> { mir::Rvalue::NullaryOp(mir::NullOp::Box, _) => { let tcx = self.tcx; let exchange_malloc_fn_def_id = - tcx.require_lang_item(ExchangeMallocFnLangItem, None); + tcx.require_lang_item(LangItem::ExchangeMalloc, None); let instance = Instance::mono(tcx, exchange_malloc_fn_def_id); if should_codegen_locally(tcx, &instance) { self.output.push(create_fn_mono_item(self.tcx, instance, span)); @@ -1083,7 +1083,7 @@ impl RootCollector<'_, 'v> { _ => return, }; - let start_def_id = match self.tcx.lang_items().require(StartFnLangItem) { + let start_def_id = match self.tcx.lang_items().require(LangItem::Start) { Ok(s) => s, Err(err) => self.tcx.sess.fatal(&err), }; diff --git a/src/librustc_mir/monomorphize/mod.rs b/src/librustc_mir/monomorphize/mod.rs index 15d7b111240..edafa00a03a 100644 --- a/src/librustc_mir/monomorphize/mod.rs +++ b/src/librustc_mir/monomorphize/mod.rs @@ -2,7 +2,7 @@ use rustc_middle::traits; use rustc_middle::ty::adjustment::CustomCoerceUnsized; use rustc_middle::ty::{self, Ty, TyCtxt}; -use rustc_hir::lang_items::CoerceUnsizedTraitLangItem; +use rustc_hir::lang_items::LangItem; pub mod collector; pub mod partitioning; @@ -13,7 +13,7 @@ pub fn custom_coerce_unsize_info<'tcx>( source_ty: Ty<'tcx>, target_ty: Ty<'tcx>, ) -> CustomCoerceUnsized { - let def_id = tcx.require_lang_item(CoerceUnsizedTraitLangItem, None); + let def_id = tcx.require_lang_item(LangItem::CoerceUnsized, None); let trait_ref = ty::Binder::bind(ty::TraitRef { def_id, diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs index 6a7653b6075..08ed0d37701 100644 --- a/src/librustc_mir/shim.rs +++ b/src/librustc_mir/shim.rs @@ -1,6 +1,6 @@ use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items::FnMutTraitLangItem; +use rustc_hir::lang_items::LangItem; use rustc_middle::mir::*; use rustc_middle::ty::query::Providers; use rustc_middle::ty::subst::{InternalSubsts, Subst}; @@ -62,7 +62,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> Body<' build_call_shim(tcx, instance, None, CallKind::Direct(def_id), None) } ty::InstanceDef::ClosureOnceShim { call_once: _ } => { - let fn_mut = tcx.require_lang_item(FnMutTraitLangItem, None); + let fn_mut = tcx.require_lang_item(LangItem::FnMut, None); let call_mut = tcx .associated_items(fn_mut) .in_definition_order() diff --git a/src/librustc_mir/transform/check_consts/validation.rs b/src/librustc_mir/transform/check_consts/validation.rs index 4812ef5a894..e21f314ca15 100644 --- a/src/librustc_mir/transform/check_consts/validation.rs +++ b/src/librustc_mir/transform/check_consts/validation.rs @@ -1,7 +1,7 @@ //! The `Visitor` responsible for actually checking a `mir::Body` for invalid operations. use rustc_errors::struct_span_err; -use rustc_hir::{self as hir, lang_items}; +use rustc_hir::{self as hir, LangItem}; use rustc_hir::{def_id::DefId, HirId}; use rustc_infer::infer::TyCtxtInferExt; use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor}; @@ -618,7 +618,7 @@ fn check_return_ty_is_sync(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, hir_id: HirId) tcx.infer_ctxt().enter(|infcx| { let cause = traits::ObligationCause::new(body.span, hir_id, traits::SharedStatic); let mut fulfillment_cx = traits::FulfillmentContext::new(); - let sync_def_id = tcx.require_lang_item(lang_items::SyncTraitLangItem, Some(body.span)); + let sync_def_id = tcx.require_lang_item(LangItem::Sync, Some(body.span)); fulfillment_cx.register_bound(&infcx, ty::ParamEnv::empty(), ty, sync_def_id, cause); if let Err(err) = fulfillment_cx.select_all_or_error(&infcx) { infcx.report_fulfillment_errors(&err, None, false); diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index e2f22c115d0..a22075e760a 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -62,7 +62,7 @@ use crate::util::storage; use rustc_data_structures::fx::FxHashMap; use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items::{GeneratorStateLangItem, PinTypeLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_index::bit_set::{BitMatrix, BitSet}; use rustc_index::vec::{Idx, IndexVec}; use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor}; @@ -395,7 +395,7 @@ fn make_generator_state_argument_indirect<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Bo fn make_generator_state_argument_pinned<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) { let ref_gen_ty = body.local_decls.raw[1].ty; - let pin_did = tcx.require_lang_item(PinTypeLangItem, Some(body.span)); + let pin_did = tcx.require_lang_item(LangItem::Pin, Some(body.span)); let pin_adt_ref = tcx.adt_def(pin_did); let substs = tcx.intern_substs(&[ref_gen_ty.into()]); let pin_ref_gen_ty = tcx.mk_adt(pin_adt_ref, substs); @@ -1270,7 +1270,7 @@ impl<'tcx> MirPass<'tcx> for StateTransform { }; // Compute GeneratorState<yield_ty, return_ty> - let state_did = tcx.require_lang_item(GeneratorStateLangItem, None); + let state_did = tcx.require_lang_item(LangItem::GeneratorState, None); let state_adt_ref = tcx.adt_def(state_did); let state_substs = tcx.intern_substs(&[yield_ty.into(), body.return_ty().into()]); let ret_ty = tcx.mk_adt(state_adt_ref, state_substs); diff --git a/src/librustc_mir/util/elaborate_drops.rs b/src/librustc_mir/util/elaborate_drops.rs index 20c2f5688eb..5d84a008d47 100644 --- a/src/librustc_mir/util/elaborate_drops.rs +++ b/src/librustc_mir/util/elaborate_drops.rs @@ -1,6 +1,6 @@ use crate::util::patch::MirPatch; use rustc_hir as hir; -use rustc_hir::lang_items::{BoxFreeFnLangItem, DropTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_index::vec::Idx; use rustc_middle::mir::*; use rustc_middle::traits::Reveal; @@ -613,7 +613,7 @@ where fn destructor_call_block(&mut self, (succ, unwind): (BasicBlock, Unwind)) -> BasicBlock { debug!("destructor_call_block({:?}, {:?})", self, succ); let tcx = self.tcx(); - let drop_trait = tcx.require_lang_item(DropTraitLangItem, None); + let drop_trait = tcx.require_lang_item(LangItem::Drop, None); let drop_fn = tcx.associated_items(drop_trait).in_definition_order().next().unwrap(); let ty = self.place_ty(self.place); let substs = tcx.mk_substs_trait(ty, &[]); @@ -971,7 +971,7 @@ where ) -> BasicBlock { let tcx = self.tcx(); let unit_temp = Place::from(self.new_temp(tcx.mk_unit())); - let free_func = tcx.require_lang_item(BoxFreeFnLangItem, Some(self.source_info.span)); + let free_func = tcx.require_lang_item(LangItem::BoxFree, Some(self.source_info.span)); let args = adt.variants[VariantIdx::new(0)] .fields .iter() diff --git a/src/librustc_mir_build/build/matches/test.rs b/src/librustc_mir_build/build/matches/test.rs index 87977d6fe89..c4a87a554a3 100644 --- a/src/librustc_mir_build/build/matches/test.rs +++ b/src/librustc_mir_build/build/matches/test.rs @@ -10,7 +10,7 @@ use crate::build::Builder; use crate::thir::pattern::compare_const_vals; use crate::thir::*; use rustc_data_structures::fx::FxIndexMap; -use rustc_hir::RangeEnd; +use rustc_hir::{LangItem, RangeEnd}; use rustc_index::bit_set::BitSet; use rustc_middle::mir::*; use rustc_middle::ty::util::IntTypeExt; @@ -359,8 +359,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { place: Place<'tcx>, mut ty: Ty<'tcx>, ) { - use rustc_hir::lang_items::EqTraitLangItem; - let mut expect = self.literal_operand(source_info.span, value); let mut val = Operand::Copy(place); @@ -414,7 +412,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { _ => bug!("non_scalar_compare called on non-reference type: {}", ty), }; - let eq_def_id = self.hir.tcx().require_lang_item(EqTraitLangItem, None); + let eq_def_id = self.hir.tcx().require_lang_item(LangItem::PartialEq, None); let method = self.hir.trait_method(eq_def_id, sym::eq, deref_ty, &[deref_ty.into()]); let bool_ty = self.hir.bool_ty(); @@ -537,10 +535,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { Some(index) } - ( - &TestKind::SwitchInt { switch_ty: _, ref options }, - &PatKind::Range(range), - ) => { + (&TestKind::SwitchInt { switch_ty: _, ref options }, &PatKind::Range(range)) => { let not_contained = self.values_not_contained_in_range(range, options).unwrap_or(false); diff --git a/src/librustc_mir_build/build/mod.rs b/src/librustc_mir_build/build/mod.rs index d3c1aa50400..71026f5096d 100644 --- a/src/librustc_mir_build/build/mod.rs +++ b/src/librustc_mir_build/build/mod.rs @@ -6,7 +6,7 @@ use rustc_attr::{self as attr, UnwindAttr}; use rustc_errors::ErrorReported; use rustc_hir as hir; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_hir::{GeneratorKind, HirIdMap, Node}; use rustc_index::vec::{Idx, IndexVec}; use rustc_infer::infer::TyCtxtInferExt; @@ -145,8 +145,7 @@ fn mir_build(tcx: TyCtxt<'_>, def: ty::WithOptConstParam<LocalDefId>) -> Body<'_ // C-variadic fns also have a `VaList` input that's not listed in `fn_sig` // (as it's created inside the body itself, not passed in from outside). let ty = if fn_sig.c_variadic && index == fn_sig.inputs().len() { - let va_list_did = - tcx.require_lang_item(lang_items::VaListTypeLangItem, Some(arg.span)); + let va_list_did = tcx.require_lang_item(LangItem::VaList, Some(arg.span)); tcx.type_of(va_list_did).subst(tcx, &[tcx.lifetimes.re_erased.into()]) } else { diff --git a/src/librustc_mir_build/thir/pattern/const_to_pat.rs b/src/librustc_mir_build/thir/pattern/const_to_pat.rs index 6dd7e0871b4..f6d3ccc1ae0 100644 --- a/src/librustc_mir_build/thir/pattern/const_to_pat.rs +++ b/src/librustc_mir_build/thir/pattern/const_to_pat.rs @@ -1,5 +1,4 @@ use rustc_hir as hir; -use rustc_hir::lang_items::EqTraitLangItem; use rustc_index::vec::Idx; use rustc_infer::infer::{InferCtxt, TyCtxtInferExt}; use rustc_middle::mir::Field; @@ -164,7 +163,7 @@ impl<'a, 'tcx> ConstToPat<'a, 'tcx> { // not *yet* implement `PartialEq`. So for now we leave this here. let ty_is_partial_eq: bool = { let partial_eq_trait_id = - self.tcx().require_lang_item(EqTraitLangItem, Some(self.span)); + self.tcx().require_lang_item(hir::LangItem::PartialEq, Some(self.span)); let obligation: PredicateObligation<'_> = predicate_for_trait_def( self.tcx(), self.param_env, diff --git a/src/librustc_passes/weak_lang_items.rs b/src/librustc_passes/weak_lang_items.rs index d5ce82ae28f..f559d66587b 100644 --- a/src/librustc_passes/weak_lang_items.rs +++ b/src/librustc_passes/weak_lang_items.rs @@ -4,7 +4,7 @@ use rustc_data_structures::fx::FxHashSet; use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; -use rustc_hir::lang_items; +use rustc_hir::lang_items::{self, LangItem}; use rustc_hir::weak_lang_items::WEAK_ITEMS_REFS; use rustc_middle::middle::lang_items::required; use rustc_middle::ty::TyCtxt; @@ -24,7 +24,7 @@ pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>, items: &mut lang_items::LanguageItem // They will never implicitly be added to the `missing` array unless we do // so here. if items.eh_personality().is_none() { - items.missing.push(lang_items::EhPersonalityLangItem); + items.missing.push(LangItem::EhPersonality); } { @@ -58,9 +58,9 @@ fn verify<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) { for (name, &item) in WEAK_ITEMS_REFS.iter() { if missing.contains(&item) && required(tcx, item) && items.require(item).is_err() { - if item == lang_items::PanicImplLangItem { + if item == LangItem::PanicImpl { tcx.sess.err("`#[panic_handler]` function required, but not found"); - } else if item == lang_items::OomLangItem { + } else if item == LangItem::Oom { tcx.sess.err("`#[alloc_error_handler]` function required, but not found"); } else { tcx.sess.err(&format!("language item required, but not found: `{}`", name)); @@ -91,7 +91,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> { fn visit_foreign_item(&mut self, i: &hir::ForeignItem<'_>) { let check_name = |attr, sym| self.tcx.sess.check_name(attr, sym); - if let Some((lang_item, _)) = hir::lang_items::extract(check_name, &i.attrs) { + if let Some((lang_item, _)) = lang_items::extract(check_name, &i.attrs) { self.register(lang_item, i.span); } intravisit::walk_foreign_item(self, i) diff --git a/src/librustc_trait_selection/infer.rs b/src/librustc_trait_selection/infer.rs index dc895ad34a9..4ec1b29bca4 100644 --- a/src/librustc_trait_selection/infer.rs +++ b/src/librustc_trait_selection/infer.rs @@ -2,7 +2,7 @@ use crate::traits::query::outlives_bounds::InferCtxtExt as _; use crate::traits::{self, TraitEngine, TraitEngineExt}; use rustc_hir as hir; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_infer::infer::outlives::env::OutlivesEnvironment; use rustc_infer::traits::ObligationCause; use rustc_middle::arena::ArenaAllocatable; @@ -47,7 +47,7 @@ impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> { return ty.is_copy_modulo_regions(self.tcx.at(span), param_env); } - let copy_def_id = self.tcx.require_lang_item(lang_items::CopyTraitLangItem, None); + let copy_def_id = self.tcx.require_lang_item(LangItem::Copy, None); // This can get called from typeck (by euv), and `moves_by_default` // rightly refuses to work with inference variables, but diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs index 7513ff6b37e..138293c9533 100644 --- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs +++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs @@ -13,7 +13,7 @@ use rustc_hir as hir; use rustc_hir::def::DefKind; use rustc_hir::def_id::DefId; use rustc_hir::intravisit::Visitor; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_hir::{AsyncGeneratorKind, GeneratorKind, Node}; use rustc_middle::ty::{ self, suggest_constraining_type_param, AdtKind, DefIdTree, Infer, InferTy, ToPredicate, Ty, @@ -2015,8 +2015,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { if let Some(body_id) = self.tcx.hir().maybe_body_owned_by(item_id) { let body = self.tcx.hir().body(body_id); if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind { - let future_trait = - self.tcx.require_lang_item(lang_items::FutureTraitLangItem, None); + let future_trait = self.tcx.require_lang_item(LangItem::Future, None); let self_ty = self.resolve_vars_if_possible(&trait_ref.self_ty()); diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs index a505d1b594c..c788e4f5c90 100644 --- a/src/librustc_trait_selection/traits/project.rs +++ b/src/librustc_trait_selection/traits/project.rs @@ -23,9 +23,7 @@ use crate::traits::error_reporting::InferCtxtExt; use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_errors::ErrorReported; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items::{ - DiscriminantTypeLangItem, FnOnceOutputLangItem, FnOnceTraitLangItem, GeneratorTraitLangItem, -}; +use rustc_hir::lang_items::LangItem; use rustc_infer::infer::resolve::OpportunisticRegionResolver; use rustc_middle::ty::fold::{TypeFoldable, TypeFolder}; use rustc_middle::ty::subst::Subst; @@ -1300,7 +1298,7 @@ fn confirm_generator_candidate<'cx, 'tcx>( let tcx = selcx.tcx(); - let gen_def_id = tcx.require_lang_item(GeneratorTraitLangItem, None); + let gen_def_id = tcx.require_lang_item(LangItem::Generator, None); let predicate = super::util::generator_trait_ref_and_outputs( tcx, @@ -1342,7 +1340,7 @@ fn confirm_discriminant_kind_candidate<'cx, 'tcx>( let self_ty = selcx.infcx().shallow_resolve(obligation.predicate.self_ty()); let substs = tcx.mk_substs([self_ty.into()].iter()); - let discriminant_def_id = tcx.require_lang_item(DiscriminantTypeLangItem, None); + let discriminant_def_id = tcx.require_lang_item(LangItem::Discriminant, None); let predicate = ty::ProjectionPredicate { projection_ty: ty::ProjectionTy { substs, item_def_id: discriminant_def_id }, @@ -1406,8 +1404,8 @@ fn confirm_callable_candidate<'cx, 'tcx>( debug!("confirm_callable_candidate({:?},{:?})", obligation, fn_sig); - let fn_once_def_id = tcx.require_lang_item(FnOnceTraitLangItem, None); - let fn_once_output_def_id = tcx.require_lang_item(FnOnceOutputLangItem, None); + let fn_once_def_id = tcx.require_lang_item(LangItem::FnOnce, None); + let fn_once_output_def_id = tcx.require_lang_item(LangItem::FnOnceOutput, None); let predicate = super::util::closure_trait_ref_and_return_type( tcx, diff --git a/src/librustc_trait_selection/traits/select/confirmation.rs b/src/librustc_trait_selection/traits/select/confirmation.rs index a04636af579..3d6eb845136 100644 --- a/src/librustc_trait_selection/traits/select/confirmation.rs +++ b/src/librustc_trait_selection/traits/select/confirmation.rs @@ -7,7 +7,7 @@ //! [rustc dev guide]: //! https://rustc-dev-guide.rust-lang.org/traits/resolution.html#confirmation use rustc_data_structures::stack::ensure_sufficient_stack; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_index::bit_set::GrowableBitSet; use rustc_infer::infer::InferOk; use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst, SubstsRef}; @@ -669,7 +669,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // We can only make objects from sized types. let tr = ty::TraitRef::new( - tcx.require_lang_item(lang_items::SizedTraitLangItem, None), + tcx.require_lang_item(LangItem::Sized, None), tcx.mk_substs_trait(source, &[]), ); nested.push(predicate_to_obligation(tr.without_const().to_predicate(tcx))); diff --git a/src/librustc_trait_selection/traits/structural_match.rs b/src/librustc_trait_selection/traits/structural_match.rs index 377d163d104..78186a5e8a5 100644 --- a/src/librustc_trait_selection/traits/structural_match.rs +++ b/src/librustc_trait_selection/traits/structural_match.rs @@ -4,7 +4,7 @@ use crate::traits::{self, TraitEngine}; use rustc_data_structures::fx::FxHashSet; use rustc_hir as hir; -use rustc_hir::lang_items::{StructuralPeqTraitLangItem, StructuralTeqTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_middle::ty::query::Providers; use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeFoldable, TypeVisitor}; use rustc_span::Span; @@ -75,7 +75,7 @@ fn type_marked_structural( let mut fulfillment_cx = traits::FulfillmentContext::new(); // require `#[derive(PartialEq)]` let structural_peq_def_id = - infcx.tcx.require_lang_item(StructuralPeqTraitLangItem, Some(cause.span)); + infcx.tcx.require_lang_item(LangItem::StructuralPeq, Some(cause.span)); fulfillment_cx.register_bound( infcx, ty::ParamEnv::empty(), @@ -86,7 +86,7 @@ fn type_marked_structural( // for now, require `#[derive(Eq)]`. (Doing so is a hack to work around // the type `for<'a> fn(&'a ())` failing to implement `Eq` itself.) let structural_teq_def_id = - infcx.tcx.require_lang_item(StructuralTeqTraitLangItem, Some(cause.span)); + infcx.tcx.require_lang_item(LangItem::StructuralTeq, Some(cause.span)); fulfillment_cx.register_bound( infcx, ty::ParamEnv::empty(), diff --git a/src/librustc_trait_selection/traits/wf.rs b/src/librustc_trait_selection/traits/wf.rs index d225b10834a..0ac3c6ffe62 100644 --- a/src/librustc_trait_selection/traits/wf.rs +++ b/src/librustc_trait_selection/traits/wf.rs @@ -3,7 +3,7 @@ use crate::opaque_types::required_region_bounds; use crate::traits; use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef}; use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable, WithConstness}; use rustc_span::Span; @@ -340,7 +340,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> { if !subty.has_escaping_bound_vars() { let cause = self.cause(cause); let trait_ref = ty::TraitRef { - def_id: self.infcx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None), + def_id: self.infcx.tcx.require_lang_item(LangItem::Sized, None), substs: self.infcx.tcx.mk_substs_trait(subty, &[]), }; self.out.push(traits::Obligation::new( diff --git a/src/librustc_ty/common_traits.rs b/src/librustc_ty/common_traits.rs index 8d153e77f0b..24ba0717866 100644 --- a/src/librustc_ty/common_traits.rs +++ b/src/librustc_ty/common_traits.rs @@ -1,27 +1,27 @@ //! Queries for checking whether a type implements one of a few common traits. -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_infer::infer::TyCtxtInferExt; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::DUMMY_SP; use rustc_trait_selection::traits; fn is_copy_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { - is_item_raw(tcx, query, lang_items::CopyTraitLangItem) + is_item_raw(tcx, query, LangItem::Copy) } fn is_sized_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { - is_item_raw(tcx, query, lang_items::SizedTraitLangItem) + is_item_raw(tcx, query, LangItem::Sized) } fn is_freeze_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool { - is_item_raw(tcx, query, lang_items::FreezeTraitLangItem) + is_item_raw(tcx, query, LangItem::Freeze) } fn is_item_raw<'tcx>( tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>, - item: lang_items::LangItem, + item: LangItem, ) -> bool { let (param_env, ty) = query.into_parts(); let trait_def_id = tcx.require_lang_item(item, None); diff --git a/src/librustc_typeck/astconv/mod.rs b/src/librustc_typeck/astconv/mod.rs index 15c19afdb4a..80dd26e9154 100644 --- a/src/librustc_typeck/astconv/mod.rs +++ b/src/librustc_typeck/astconv/mod.rs @@ -16,7 +16,7 @@ use rustc_hir as hir; use rustc_hir::def::{CtorOf, DefKind, Namespace, Res}; use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::intravisit::{walk_generics, Visitor as _}; -use rustc_hir::lang_items::SizedTraitLangItem; +use rustc_hir::lang_items::LangItem; use rustc_hir::{Constness, GenericArg, GenericArgs}; use rustc_middle::ty::subst::{self, InternalSubsts, Subst, SubstsRef}; use rustc_middle::ty::GenericParamDefKind; @@ -696,7 +696,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { } } - let kind_id = tcx.lang_items().require(SizedTraitLangItem); + let kind_id = tcx.lang_items().require(LangItem::Sized); match unbound { Some(tpb) => { // FIXME(#8559) currently requires the unbound to be built-in. diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 34693a73217..e41314e8ab0 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -35,7 +35,7 @@ use crate::type_error_struct; use rustc_ast as ast; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported}; use rustc_hir as hir; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_middle::ty::adjustment::AllowTwoPhase; use rustc_middle::ty::cast::{CastKind, CastTy}; use rustc_middle::ty::error::TypeError; @@ -838,7 +838,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn type_is_known_to_be_sized_modulo_regions(&self, ty: Ty<'tcx>, span: Span) -> bool { - let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None); + let lang_item = self.tcx.require_lang_item(LangItem::Sized, None); traits::type_known_to_meet_bound_modulo_regions(self, self.param_env, ty, lang_item, span) } } diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index c7f9e9d63e0..97f7e4537ce 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -5,7 +5,7 @@ use super::{check_fn, Expectation, FnCtxt, GeneratorTypes}; use crate::astconv::AstConv; use rustc_hir as hir; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items::{FutureTraitLangItem, GeneratorTraitLangItem}; +use rustc_hir::lang_items::LangItem; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc_infer::infer::LateBoundRegionConversionTime; use rustc_infer::infer::{InferOk, InferResult}; @@ -245,7 +245,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let trait_ref = projection.to_poly_trait_ref(tcx); let is_fn = tcx.fn_trait_kind_from_lang_item(trait_ref.def_id()).is_some(); - let gen_trait = tcx.require_lang_item(GeneratorTraitLangItem, cause_span); + let gen_trait = tcx.require_lang_item(LangItem::Generator, cause_span); let is_gen = gen_trait == trait_ref.def_id(); if !is_fn && !is_gen { debug!("deduce_sig_from_projection: not fn or generator"); @@ -668,7 +668,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // Check that this is a projection from the `Future` trait. let trait_ref = predicate.projection_ty.trait_ref(self.tcx); - let future_trait = self.tcx.require_lang_item(FutureTraitLangItem, Some(cause_span)); + let future_trait = self.tcx.require_lang_item(LangItem::Future, Some(cause_span)); if trait_ref.def_id != future_trait { debug!("deduce_future_output_from_projection: not a future"); return None; diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index aa92d8b8b2b..5dc5480c335 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -6,7 +6,7 @@ use rustc_trait_selection::traits::ObligationCause; use rustc_ast::util::parser::PREC_POSTFIX; use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir as hir; -use rustc_hir::lang_items::CloneTraitLangItem; +use rustc_hir::lang_items::LangItem; use rustc_hir::{is_range_literal, Node}; use rustc_middle::ty::adjustment::AllowTwoPhase; use rustc_middle::ty::{self, AssocItem, Ty, TypeAndMut}; @@ -465,7 +465,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if self.can_coerce(ref_ty, expected) { let mut sugg_sp = sp; if let hir::ExprKind::MethodCall(ref segment, sp, ref args, _) = expr.kind { - let clone_trait = self.tcx.require_lang_item(CloneTraitLangItem, Some(sp)); + let clone_trait = self.tcx.require_lang_item(LangItem::Clone, Some(sp)); if let ([arg], Some(true), sym::clone) = ( &args[..], self.typeck_results.borrow().type_dependent_def_id(expr.hir_id).map( diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index ff0c788c18b..0e9f64c3596 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -25,7 +25,7 @@ use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, use rustc_hir as hir; use rustc_hir::def::{CtorKind, DefKind, Res}; use rustc_hir::def_id::DefId; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_hir::{ExprKind, QPath}; use rustc_infer::infer; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; @@ -926,8 +926,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // Try alternative arbitrary self types that could fulfill this call. // FIXME: probe for all types that *could* be arbitrary self-types, not // just this list. - try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::OwnedBoxLangItem)); - try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::PinTypeLangItem)); + try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, LangItem::OwnedBox)); + try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, LangItem::Pin)); try_alt_rcvr(&mut err, self.tcx.mk_diagnostic_item(rcvr_t, sym::Arc)); try_alt_rcvr(&mut err, self.tcx.mk_diagnostic_item(rcvr_t, sym::Rc)); } diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index e941c844a6d..896bfc07954 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -9,7 +9,7 @@ use rustc_hir as hir; use rustc_hir::def::{DefKind, Namespace, Res}; use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc_hir::intravisit; -use rustc_hir::lang_items::FnOnceTraitLangItem; +use rustc_hir::lang_items::LangItem; use rustc_hir::{ExprKind, Node, QPath}; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc_middle::hir::map as hir_map; @@ -36,7 +36,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ty::Closure(..) | ty::FnDef(..) | ty::FnPtr(_) => true, // If it's not a simple function, look for things which implement `FnOnce`. _ => { - let fn_once = match tcx.lang_items().require(FnOnceTraitLangItem) { + let fn_once = match tcx.lang_items().require(LangItem::FnOnce) { Ok(fn_once) => fn_once, Err(..) => return false, }; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 824e81a974c..031d48f8a60 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -100,9 +100,7 @@ use rustc_hir::def::{CtorOf, DefKind, Res}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LOCAL_CRATE}; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_hir::itemlikevisit::ItemLikeVisitor; -use rustc_hir::lang_items::{ - FutureTraitLangItem, PinTypeLangItem, SizedTraitLangItem, VaListTypeLangItem, -}; +use rustc_hir::lang_items::LangItem; use rustc_hir::{ExprKind, GenericArg, HirIdMap, ItemKind, Node, PatKind, QPath}; use rustc_index::bit_set::BitSet; use rustc_index::vec::Idx; @@ -1339,7 +1337,7 @@ fn check_fn<'a, 'tcx>( // (as it's created inside the body itself, not passed in from outside). let maybe_va_list = if fn_sig.c_variadic { let span = body.params.last().unwrap().span; - let va_list_did = tcx.require_lang_item(VaListTypeLangItem, Some(span)); + let va_list_did = tcx.require_lang_item(LangItem::VaList, Some(span)); let region = fcx.next_region_var(RegionVariableOrigin::MiscVariable(span)); Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()])) @@ -3493,7 +3491,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { code: traits::ObligationCauseCode<'tcx>, ) { if !ty.references_error() { - let lang_item = self.tcx.require_lang_item(SizedTraitLangItem, None); + let lang_item = self.tcx.require_lang_item(LangItem::Sized, None); self.require_type_meets(ty, span, code, lang_item); } } @@ -5265,7 +5263,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { _ => {} } let boxed_found = self.tcx.mk_box(found); - let new_found = self.tcx.mk_lang_item(boxed_found, PinTypeLangItem).unwrap(); + let new_found = self.tcx.mk_lang_item(boxed_found, LangItem::Pin).unwrap(); if let (true, Ok(snippet)) = ( self.can_coerce(new_found, expected), self.sess().source_map().span_to_snippet(expr.span), @@ -5422,7 +5420,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let sp = expr.span; // Check for `Future` implementations by constructing a predicate to // prove: `<T as Future>::Output == U` - let future_trait = self.tcx.require_lang_item(FutureTraitLangItem, Some(sp)); + let future_trait = self.tcx.require_lang_item(LangItem::Future, Some(sp)); let item_def_id = self .tcx .associated_items(future_trait) diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 810bf59ea6c..9c692edaa7f 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -9,7 +9,7 @@ use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::intravisit as hir_visit; use rustc_hir::intravisit::Visitor; use rustc_hir::itemlikevisit::ParItemLikeVisitor; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_hir::ItemKind; use rustc_middle::hir::map as hir_map; use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts, Subst}; @@ -495,7 +495,7 @@ fn check_type_defn<'tcx, F>( let last = idx == variant.fields.len() - 1; fcx.register_bound( field.ty, - fcx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None), + fcx.tcx.require_lang_item(LangItem::Sized, None), traits::ObligationCause::new( field.span, fcx.body_id, @@ -718,7 +718,7 @@ fn check_item_type(tcx: TyCtxt<'_>, item_id: hir::HirId, ty_span: Span, allow_fo if forbid_unsized { fcx.register_bound( item_ty, - fcx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None), + fcx.tcx.require_lang_item(LangItem::Sized, None), traits::ObligationCause::new(ty_span, fcx.body_id, traits::MiscObligation), ); } @@ -1223,7 +1223,7 @@ fn receiver_is_valid<'fcx, 'tcx>( // The first type is `receiver_ty`, which we know its not equal to `self_ty`; skip it. autoderef.next(); - let receiver_trait_def_id = fcx.tcx.require_lang_item(lang_items::ReceiverTraitLangItem, None); + let receiver_trait_def_id = fcx.tcx.require_lang_item(LangItem::Receiver, None); // Keep dereferencing `receiver_ty` until we get to `self_ty`. loop { diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index 56a737964c0..0d3cac7f7f3 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -4,9 +4,7 @@ use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::def_id::{DefId, LocalDefId}; -use rustc_hir::lang_items::{ - CoerceUnsizedTraitLangItem, DispatchFromDynTraitLangItem, UnsizeTraitLangItem, -}; +use rustc_hir::lang_items::LangItem; use rustc_hir::ItemKind; use rustc_infer::infer; use rustc_infer::infer::outlives::env::OutlivesEnvironment; @@ -149,7 +147,7 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_did); let span = tcx.hir().span(impl_hir_id); - let dispatch_from_dyn_trait = tcx.require_lang_item(DispatchFromDynTraitLangItem, Some(span)); + let dispatch_from_dyn_trait = tcx.require_lang_item(LangItem::DispatchFromDyn, Some(span)); let source = tcx.type_of(impl_did); assert!(!source.has_escaping_bound_vars()); @@ -318,9 +316,9 @@ pub fn coerce_unsized_info(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedI let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_did.expect_local()); let span = tcx.hir().span(impl_hir_id); - let coerce_unsized_trait = tcx.require_lang_item(CoerceUnsizedTraitLangItem, Some(span)); + let coerce_unsized_trait = tcx.require_lang_item(LangItem::CoerceUnsized, Some(span)); - let unsize_trait = tcx.lang_items().require(UnsizeTraitLangItem).unwrap_or_else(|err| { + let unsize_trait = tcx.lang_items().require(LangItem::Unsize).unwrap_or_else(|err| { tcx.sess.fatal(&format!("`CoerceUnsized` implementation {}", err)); }); diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index 9c44d27447d..1ea1a091069 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -1,6 +1,6 @@ use rustc_data_structures::fx::FxHashSet; use rustc_hir as hir; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_middle::ty::{self, Region, RegionVid, TypeFoldable}; use rustc_trait_selection::traits::auto_trait::{self, AutoTraitResult}; @@ -454,7 +454,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { // The `Sized` trait must be handled specially, since we only display it when // it is *not* required (i.e., '?Sized') - let sized_trait = self.cx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None); + let sized_trait = self.cx.tcx.require_lang_item(LangItem::Sized, None); let mut replacer = RegionReplacer { vid_to_region: &vid_to_region, tcx }; @@ -742,9 +742,9 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { fn is_fn_ty(&self, tcx: TyCtxt<'_>, ty: &Type) -> bool { match &ty { &&Type::ResolvedPath { ref did, .. } => { - *did == tcx.require_lang_item(lang_items::FnTraitLangItem, None) - || *did == tcx.require_lang_item(lang_items::FnMutTraitLangItem, None) - || *did == tcx.require_lang_item(lang_items::FnOnceTraitLangItem, None) + *did == tcx.require_lang_item(LangItem::Fn, None) + || *did == tcx.require_lang_item(LangItem::FnMut, None) + || *did == tcx.require_lang_item(LangItem::FnOnce, None) } _ => false, } diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index 932585918df..a458cdab303 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -16,7 +16,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir as hir; use rustc_hir::def::Res; use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; -use rustc_hir::lang_items; +use rustc_hir::lang_items::LangItem; use rustc_hir::Mutability; use rustc_index::vec::IndexVec; use rustc_middle::middle::stability; @@ -710,7 +710,7 @@ pub enum GenericBound { impl GenericBound { pub fn maybe_sized(cx: &DocContext<'_>) -> GenericBound { - let did = cx.tcx.require_lang_item(lang_items::SizedTraitLangItem, None); + let did = cx.tcx.require_lang_item(LangItem::Sized, None); let empty = cx.tcx.intern_substs(&[]); let path = external_path(cx, cx.tcx.item_name(did), Some(did), false, vec![], empty); inline::record_extern_fqn(cx, did, TypeKind::Trait); |