diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs
index 4c810a37d4180..f3326151e9a67 100644
--- a/src/librustc_codegen_llvm/context.rs
+++ b/src/librustc_codegen_llvm/context.rs
@@ -12,6 +12,7 @@ use rustc_data_structures::base_n;
 use rustc_data_structures::const_cstr;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::small_c_str::SmallCStr;
+use rustc_hir::LangItemRecord;
 use rustc_middle::bug;
 use rustc_middle::mir::mono::CodegenUnit;
 use rustc_middle::ty::layout::{HasParamEnv, LayoutError, TyAndLayout};
@@ -340,7 +341,7 @@ impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         }
         let tcx = self.tcx;
         let llfn = match tcx.lang_items().eh_personality() {
-            Some(def_id) if !wants_msvc_seh(self.sess()) => self.get_fn_addr(
+            LangItemRecord::Present(def_id) if !wants_msvc_seh(self.sess()) => self.get_fn_addr(
                 ty::Instance::resolve(
                     tcx,
                     ty::ParamEnv::reveal_all(),
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index 1e6d2e3dbb74e..22870d7fce6b8 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -17,6 +17,7 @@ use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::MemFlags;
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_middle::ty::layout::{FnAbiExt, HasTyCtxt};
 use rustc_middle::ty::{self, Ty};
 use rustc_middle::{bug, span_bug};
@@ -1009,11 +1010,11 @@ fn codegen_gnu_try(
         let lpad_ty = bx.type_struct(&[bx.type_i8p(), bx.type_i32()], false);
         let vals = catch.landing_pad(lpad_ty, bx.eh_personality(), 1);
         let tydesc = match bx.tcx().lang_items().eh_catch_typeinfo() {
-            Some(tydesc) => {
+            LangItemRecord::Present(tydesc) => {
                 let tydesc = bx.get_static(tydesc);
                 bx.bitcast(tydesc, bx.type_i8p())
             }
-            None => bx.const_null(bx.type_i8p()),
+            _ => bx.const_null(bx.type_i8p()),
         };
         catch.add_clause(vals, tydesc);
         let ptr = catch.extract_value(vals, 0);
diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs
index 98f7da8361cc4..0b0f82165dc94 100644
--- a/src/librustc_codegen_ssa/back/symbol_export.rs
+++ b/src/librustc_codegen_ssa/back/symbol_export.rs
@@ -5,7 +5,7 @@ use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, CRATE_DEF_INDEX, LOCAL_CRATE};
-use rustc_hir::Node;
+use rustc_hir::{LangItemRecord, Node};
 use rustc_index::vec::IndexVec;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::exported_symbols::{
@@ -304,7 +304,9 @@ fn upstream_monomorphizations_provider(
             let (def_id, substs) = match *exported_symbol {
                 ExportedSymbol::Generic(def_id, substs) => (def_id, substs),
                 ExportedSymbol::DropGlue(ty) => {
-                    if let Some(drop_in_place_fn_def_id) = drop_in_place_fn_def_id {
+                    if let LangItemRecord::Present(drop_in_place_fn_def_id) =
+                        drop_in_place_fn_def_id
+                    {
                         (drop_in_place_fn_def_id, tcx.intern_substs(&[ty.into()]))
                     } else {
                         // `drop_in_place` in place does not exist, don't try
@@ -351,7 +353,7 @@ fn upstream_drop_glue_for_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     substs: SubstsRef<'tcx>,
 ) -> Option<CrateNum> {
-    if let Some(def_id) = tcx.lang_items().drop_in_place_fn() {
+    if let LangItemRecord::Present(def_id) = tcx.lang_items().drop_in_place_fn() {
         tcx.upstream_monomorphizations_for(def_id).and_then(|monos| monos.get(&substs).cloned())
     } else {
         None
diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs
index 5b14258bd25be..2fa15eedd7d4a 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::LangItemRecord;
 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().lang_items().start_fn().require(&cx.tcx(), None);
             let start_fn = cx.get_fn_addr(
                 ty::Instance::resolve(
                     cx.tcx(),
@@ -837,7 +837,7 @@ impl CrateInfo {
             }
             let missing = tcx.missing_lang_items(cnum);
             for &item in missing.iter() {
-                if let Ok(id) = lang_items.require(item) {
+                if let LangItemRecord::Present(id) = lang_items.get(item) {
                     info.lang_item_to_crate.insert(item, id.krate);
                 }
             }
diff --git a/src/librustc_codegen_ssa/common.rs b/src/librustc_codegen_ssa/common.rs
index 0d0321ec4ae5e..985e3452e32a2 100644
--- a/src/librustc_codegen_ssa/common.rs
+++ b/src/librustc_codegen_ssa/common.rs
@@ -120,13 +120,7 @@ mod temp_stable_hash_impls {
 }
 
 pub fn langcall(tcx: TyCtxt<'_>, span: Option<Span>, msg: &str, li: LangItem) -> DefId {
-    tcx.lang_items().require(li).unwrap_or_else(|s| {
-        let msg = format!("{} {}", msg, s);
-        match span {
-            Some(span) => tcx.sess.span_fatal(span, &msg[..]),
-            None => tcx.sess.fatal(&msg[..]),
-        }
-    })
+    tcx.lang_items().get(li).require_with(&tcx, span, |err| format!("{} {}", msg, err))
 }
 
 // To avoid UB from LLVM, these two functions mask RHS with an
diff --git a/src/librustc_codegen_ssa/mir/analyze.rs b/src/librustc_codegen_ssa/mir/analyze.rs
index db935c2b3e265..685c298ad221d 100644
--- a/src/librustc_codegen_ssa/mir/analyze.rs
+++ b/src/librustc_codegen_ssa/mir/analyze.rs
@@ -245,7 +245,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
             _ => None,
         };
         if let Some((def_id, args)) = check {
-            if Some(def_id) == self.fx.cx.tcx().lang_items().box_free_fn() {
+            if self.fx.cx.tcx().lang_items().box_free_fn().has_def_id(def_id) {
                 // box_free(x) shares with `drop x` the property that it
                 // is not guaranteed to be statically dominated by the
                 // definition of x, so x must always be in an alloca.
diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs
index 57f72b1065d05..7a38cd9509626 100644
--- a/src/librustc_codegen_ssa/mir/rvalue.rs
+++ b/src/librustc_codegen_ssa/mir/rvalue.rs
@@ -8,7 +8,6 @@ use crate::traits::*;
 use crate::MemFlags;
 
 use rustc_apfloat::{ieee, Float, Round, Status};
-use rustc_hir::lang_items::ExchangeMallocFnLangItem;
 use rustc_middle::mir;
 use rustc_middle::ty::cast::{CastTy, IntTy};
 use rustc_middle::ty::layout::HasTyCtxt;
@@ -508,12 +507,12 @@ 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) {
-                    Ok(id) => id,
-                    Err(s) => {
-                        bx.cx().sess().fatal(&format!("allocation of `{}` {}", box_layout.ty, s));
-                    }
-                };
+                let def_id = bx.tcx().lang_items().exchange_malloc_fn().require_with(
+                    &bx.tcx(),
+                    None,
+                    |err| format!("allocation of `{}` {}", box_layout.ty, err),
+                );
+
                 let instance = ty::Instance::mono(bx.tcx(), def_id);
                 let r = bx.cx().get_fn_addr(instance);
                 let call = bx.call(r, &[llsize, llalign], None);
diff --git a/src/librustc_hir/lang_items.rs b/src/librustc_hir/lang_items.rs
index 83bada4041963..9b1f344a673e6 100644
--- a/src/librustc_hir/lang_items.rs
+++ b/src/librustc_hir/lang_items.rs
@@ -47,44 +47,122 @@ macro_rules! language_item_table {
             }
         }
 
+        pub trait MissingLangItemHandler {
+            fn span_fatal(&self, span: Span, msg: &str) -> !;
+
+            fn fatal(&self, msg: &str) -> !;
+        }
+
+        /// Represents the presence or possibly lack-of a particular lang item.
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
+        pub enum LangItemRecord {
+            /// The lang item is present and has been assigned this `DefId`.
+            Present(DefId),
+            /// The lang item is missing (we keep the variant representing the item around
+            /// in case we need it for error reporting etc.).
+            Missing(LangItem),
+        }
+
+        impl LangItemRecord {
+            #[inline]
+            pub fn has_def_id(self, def_id: DefId) -> bool {
+                match self {
+                    LangItemRecord::Present(assigned_id) if assigned_id == def_id => true,
+                    _ => false,
+                }
+            }
+
+            #[inline]
+            pub fn require<H: MissingLangItemHandler>(self, handler: &H, span: Option<Span>) -> DefId {
+                self.require_with(handler, span, str::to_string)
+            }
+
+            pub fn require_with<H, F>(self, handler: &H, span: Option<Span>, err: F) -> DefId
+            where
+                H: MissingLangItemHandler,
+                F: Fn(&str) -> String,
+            {
+                match self {
+                    LangItemRecord::Present(assigned_id) => assigned_id,
+                    LangItemRecord::Missing(it) => {
+                        let msg = err(&format!("requires `{}` lang_item", it.name()));
+                        if let Some(span) = span {
+                            handler.span_fatal(span, &msg)
+                        } else {
+                            handler.fatal(&msg)
+                        }
+                    }
+                }
+            }
+
+            #[inline]
+            pub fn is_present(self) -> bool {
+                match self {
+                    LangItemRecord::Present(_) => true,
+                    _ => false,
+                }
+            }
+
+            #[inline]
+            pub fn is_missing(self) -> bool {
+                !self.is_present()
+            }
+
+            #[inline]
+            pub fn is_local(self) -> bool {
+                match self {
+                    LangItemRecord::Present(assigned_id) => assigned_id.is_local(),
+                    _ => false,
+                }
+            }
+        }
+
         #[derive(HashStable_Generic)]
         pub struct LanguageItems {
-            /// Mappings from lang items to their possibly found `DefId`s.
+            /// Mappings from lang items to their corresponding record.
             /// The index corresponds to the order in `LangItem`.
-            pub items: Vec<Option<DefId>>,
-            /// Lang items that were not found during collection.
-            pub missing: Vec<LangItem>,
+            // FIXME(doctorn) use Box<[LangItemRecord; std::mem::num_variants::<LangItem>()]>
+            pub items: Vec<LangItemRecord>,
         }
 
         impl LanguageItems {
-            /// Construct an empty collection of lang items and no missing ones.
+            /// Construct an empty collection of lang items. We initially assume that all items are
+            /// missing.
             pub fn new() -> Self {
-                fn init_none(_: LangItem) -> Option<DefId> { None }
+                fn init_missing(it: LangItem) -> LangItemRecord {
+                    LangItemRecord::Missing(it)
+                }
 
                 Self {
-                    items: vec![$(init_none($variant)),*],
-                    missing: Vec::new(),
+                    items: vec![$(init_missing($variant)),*],
                 }
             }
 
-            /// Returns the mappings to the possibly found `DefId`s for each lang item.
-            pub fn items(&self) -> &[Option<DefId>] {
+            /// Returns the `LangItemRecord` of each lang item.
+            pub fn items(&self) -> &[LangItemRecord] {
                 &*self.items
             }
 
-            /// Requires that a given `LangItem` was bound and returns the corresponding `DefId`.
-            /// If it wasn't bound, e.g. due to a missing `#[lang = "<it.name()>"]`,
-            /// returns an error message as a string.
-            pub fn require(&self, it: LangItem) -> Result<DefId, String> {
-                self.items[it as usize].ok_or_else(|| format!("requires `{}` lang_item", it.name()))
+            /// Returns the missing lang items.
+            pub fn missing(&self) -> impl Iterator<Item = LangItem> + '_ {
+                self.items.iter().copied().filter_map(|record| {
+                    match record {
+                        LangItemRecord::Missing(it) => Some(it),
+                        _ => None,
+                    }
+                })
+            }
+
+            /// Returns the `LangItemRecord` of a specific lang item.
+            pub fn get(&self, it: LangItem) -> LangItemRecord {
+                self.items[it as usize]
             }
 
             $(
-                /// Returns the corresponding `DefId` for the lang item
+                /// Returns the `LangItemRecord` for the lang item.
                 #[doc = $name]
-                /// if it exists.
                 #[allow(dead_code)]
-                pub fn $method(&self) -> Option<DefId> {
+                pub fn $method(&self) -> LangItemRecord {
                     self.items[$variant as usize]
                 }
             )*
@@ -109,6 +187,12 @@ impl<CTX> HashStable<CTX> for LangItem {
     }
 }
 
+impl<CTX> HashStable<CTX> for LangItemRecord {
+    fn hash_stable(&self, _: &mut CTX, hasher: &mut StableHasher) {
+        ::std::hash::Hash::hash(self, hasher);
+    }
+}
+
 /// Extracts the first `lang = "$name"` out of a list of attributes.
 /// The attributes `#[panic_handler]` and `#[alloc_error_handler]`
 /// are also extracted out when found.
diff --git a/src/librustc_hir/lib.rs b/src/librustc_hir/lib.rs
index b51c0a6e98840..35e456d297449 100644
--- a/src/librustc_hir/lib.rs
+++ b/src/librustc_hir/lib.rs
@@ -30,6 +30,6 @@ pub mod weak_lang_items;
 
 pub use hir::*;
 pub use hir_id::*;
-pub use lang_items::{LangItem, LanguageItems};
+pub use lang_items::{LangItem, LangItemRecord, LanguageItems, MissingLangItemHandler};
 pub use stable_hash_impls::HashStableContext;
 pub use target::{MethodKind, Target};
diff --git a/src/librustc_hir/weak_lang_items.rs b/src/librustc_hir/weak_lang_items.rs
index c0560eb8d455a..79cdd5c5b5209 100644
--- a/src/librustc_hir/weak_lang_items.rs
+++ b/src/librustc_hir/weak_lang_items.rs
@@ -32,9 +32,7 @@ pub fn link_name(attrs: &[ast::Attribute]) -> Option<Symbol> {
 
 impl LanguageItems {
     pub fn is_weak_lang_item(&self, item_def_id: DefId) -> bool {
-        let did = Some(item_def_id);
-
-        $(self.$name() == did)||*
+        $(self.$name().has_def_id(item_def_id))||*
     }
 }
 
diff --git a/src/librustc_metadata/rmeta/encoder.rs b/src/librustc_metadata/rmeta/encoder.rs
index d797e6d4a34af..2b553d1a0baec 100644
--- a/src/librustc_metadata/rmeta/encoder.rs
+++ b/src/librustc_metadata/rmeta/encoder.rs
@@ -15,7 +15,7 @@ use rustc_hir::definitions::DefPathTable;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::itemlikevisit::{ItemLikeVisitor, ParItemLikeVisitor};
 use rustc_hir::lang_items;
-use rustc_hir::{AnonConst, GenericParamKind};
+use rustc_hir::{AnonConst, GenericParamKind, LangItemRecord};
 use rustc_index::vec::Idx;
 use rustc_middle::hir::map::Map;
 use rustc_middle::middle::cstore::{EncodedMetadata, ForeignModule, LinkagePreference, NativeLib};
@@ -1155,7 +1155,7 @@ impl EncodeContext<'tcx> {
                 // "unsized info", else just store None
                 let coerce_unsized_info =
                     trait_ref.and_then(|t| {
-                        if Some(t.def_id) == self.tcx.lang_items().coerce_unsized_trait() {
+                        if self.tcx.lang_items().coerce_unsized_trait().has_def_id(t.def_id) {
                             Some(self.tcx.at(item.span).coerce_unsized_info(def_id))
                         } else {
                             None
@@ -1441,7 +1441,7 @@ impl EncodeContext<'tcx> {
         let lang_items = tcx.lang_items();
         let lang_items = lang_items.items().iter();
         self.lazy(lang_items.enumerate().filter_map(|(i, &opt_def_id)| {
-            if let Some(def_id) = opt_def_id {
+            if let LangItemRecord::Present(def_id) = opt_def_id {
                 if def_id.is_local() {
                     return Some((def_id.index, i));
                 }
@@ -1452,7 +1452,7 @@ impl EncodeContext<'tcx> {
 
     fn encode_lang_items_missing(&mut self) -> Lazy<[lang_items::LangItem]> {
         let tcx = self.tcx;
-        self.lazy(&tcx.lang_items().missing)
+        self.lazy(tcx.lang_items().missing())
     }
 
     /// Encodes an index, mapping each trait to its (local) implementations.
diff --git a/src/librustc_middle/middle/lang_items.rs b/src/librustc_middle/middle/lang_items.rs
index 0f98c338c16b1..f7ff0525e86ff 100644
--- a/src/librustc_middle/middle/lang_items.rs
+++ b/src/librustc_middle/middle/lang_items.rs
@@ -10,29 +10,17 @@
 use crate::ty::{self, TyCtxt};
 
 use rustc_hir::def_id::DefId;
-use rustc_hir::LangItem;
+use rustc_hir::{LangItem, MissingLangItemHandler};
 use rustc_span::Span;
 use rustc_target::spec::PanicStrategy;
 
 impl<'tcx> TyCtxt<'tcx> {
-    /// Returns the `DefId` for a given `LangItem`.
-    /// If not found, fatally aborts compilation.
-    pub fn require_lang_item(&self, lang_item: LangItem, span: Option<Span>) -> DefId {
-        self.lang_items().require(lang_item).unwrap_or_else(|msg| {
-            if let Some(span) = span {
-                self.sess.span_fatal(span, &msg)
-            } else {
-                self.sess.fatal(&msg)
-            }
-        })
-    }
-
     pub fn fn_trait_kind_from_lang_item(&self, id: DefId) -> Option<ty::ClosureKind> {
         let items = self.lang_items();
-        match Some(id) {
-            x if x == items.fn_trait() => Some(ty::ClosureKind::Fn),
-            x if x == items.fn_mut_trait() => Some(ty::ClosureKind::FnMut),
-            x if x == items.fn_once_trait() => Some(ty::ClosureKind::FnOnce),
+        match id {
+            x if items.fn_trait().has_def_id(x) => Some(ty::ClosureKind::Fn),
+            x if items.fn_mut_trait().has_def_id(x) => Some(ty::ClosureKind::FnMut),
+            x if items.fn_once_trait().has_def_id(x) => Some(ty::ClosureKind::FnOnce),
             _ => None,
         }
     }
@@ -42,6 +30,16 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
+impl<'tcx> MissingLangItemHandler for TyCtxt<'tcx> {
+    fn span_fatal(&self, span: Span, msg: &str) -> ! {
+        self.sess.span_fatal(span, msg)
+    }
+
+    fn fatal(&self, msg: &str) -> ! {
+        self.sess.fatal(msg)
+    }
+}
+
 /// Returns `true` if the specified `lang_item` doesn't actually need to be
 /// present for this compilation.
 ///
@@ -52,8 +50,16 @@ pub fn whitelisted(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool {
     // If we're not compiling with unwinding, we won't actually need these
     // symbols. Other panic runtimes ensure that the relevant symbols are
     // available to link things together, but they're never exercised.
-    if tcx.sess.panic_strategy() != PanicStrategy::Unwind {
-        return lang_item == LangItem::EhPersonalityLangItem;
+    if tcx.sess.panic_strategy() != PanicStrategy::Unwind
+        && lang_item == LangItem::EhPersonalityLangItem
+    {
+        return true;
+    }
+
+    // If we don't require an allocator then we don't require
+    // `#[alloc_error_handler]`.
+    if tcx.allocator_kind().is_none() && lang_item == LangItem::OomLangItem {
+        return true;
     }
 
     false
diff --git a/src/librustc_middle/traits/query.rs b/src/librustc_middle/traits/query.rs
index 69696ac9e93c0..4e1f88b2a1e6a 100644
--- a/src/librustc_middle/traits/query.rs
+++ b/src/librustc_middle/traits/query.rs
@@ -234,7 +234,7 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         }
 
         ty::Adt(def, _) => {
-            if Some(def.did) == tcx.lang_items().manually_drop() {
+            if tcx.lang_items().manually_drop().has_def_id(def.did) {
                 // `ManuallyDrop` never has a dtor.
                 true
             } else {
diff --git a/src/librustc_middle/ty/adjustment.rs b/src/librustc_middle/ty/adjustment.rs
index 52ebcd63e7cda..47d9a01613e6a 100644
--- a/src/librustc_middle/ty/adjustment.rs
+++ b/src/librustc_middle/ty/adjustment.rs
@@ -2,7 +2,6 @@ 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_macros::HashStable;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
@@ -118,8 +117,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.lang_items().deref_trait().require(&tcx, None),
+            hir::Mutability::Mut => tcx.lang_items().deref_mut_trait().require(&tcx, 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 62d6de2d71e6d..8b7a7794aff57 100644
--- a/src/librustc_middle/ty/context.rs
+++ b/src/librustc_middle/ty/context.rs
@@ -37,7 +37,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId, LOCAL_CRATE};
 use rustc_hir::definitions::{DefPathHash, Definitions};
-use rustc_hir::lang_items::{self, PanicLocationLangItem};
+use rustc_hir::lang_items::{self, LangItemRecord};
 use rustc_hir::{HirId, ItemKind, ItemLocalId, ItemLocalMap, ItemLocalSet, Node, TraitCandidate};
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_macros::HashStable;
@@ -1526,7 +1526,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.lang_items().panic_location().require(self, None))
                 .subst(*self, self.mk_substs([self.lifetimes.re_static.into()].iter())),
         )
     }
@@ -2189,14 +2189,16 @@ 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.lang_items().owned_box().require(&self, 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>> {
-        let def_id = self.lang_items().require(item).ok()?;
-        Some(self.mk_generic_adt(def_id, ty))
+        match self.lang_items().get(item) {
+            LangItemRecord::Present(def_id) => Some(self.mk_generic_adt(def_id, ty)),
+            _ => None,
+        }
     }
 
     #[inline]
@@ -2207,7 +2209,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.lang_items().maybe_uninit().require(&self, None);
         self.mk_generic_adt(def_id, ty)
     }
 
@@ -2748,6 +2750,6 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
     providers.has_panic_handler = |tcx, cnum| {
         assert_eq!(cnum, LOCAL_CRATE);
         // We want to check if the panic handler was defined in this crate
-        tcx.lang_items().panic_impl().map_or(false, |did| did.is_local())
+        tcx.lang_items().panic_impl().is_local()
     };
 }
diff --git a/src/librustc_middle/ty/diagnostics.rs b/src/librustc_middle/ty/diagnostics.rs
index a2812e117ed39..afa2974f785ba 100644
--- a/src/librustc_middle/ty/diagnostics.rs
+++ b/src/librustc_middle/ty/diagnostics.rs
@@ -94,7 +94,7 @@ pub fn suggest_constraining_type_param(
     let msg_restrict_type_further =
         format!("consider further restricting type parameter `{}`", param_name);
 
-    if def_id == tcx.lang_items().sized_trait() {
+    if def_id.map_or(false, |def_id| tcx.lang_items().sized_trait().has_def_id(def_id)) {
         // Type parameters are already `Sized` by default.
         err.span_label(param.span, &format!("this type parameter needs to be `{}`", constraint));
         return true;
diff --git a/src/librustc_middle/ty/instance.rs b/src/librustc_middle/ty/instance.rs
index 1ce079821a22e..2cc9c10de7007 100644
--- a/src/librustc_middle/ty/instance.rs
+++ b/src/librustc_middle/ty/instance.rs
@@ -4,7 +4,6 @@ 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_macros::HashStable;
 
 use std::fmt;
@@ -364,7 +363,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.lang_items().drop_in_place_fn().require(&tcx, None);
         let substs = tcx.intern_substs(&[ty.into()]);
         Instance::resolve(tcx, ty::ParamEnv::reveal_all(), def_id, substs).unwrap().unwrap()
     }
@@ -375,7 +374,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.lang_items().fn_once_trait().require(&tcx, 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 d58ebdc8dfc4d..7ff920fb1c1c0 100644
--- a/src/librustc_middle/ty/layout.rs
+++ b/src/librustc_middle/ty/layout.rs
@@ -8,7 +8,6 @@ use rustc_ast::ast::{self, 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_index::bit_set::BitSet;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_session::{DataTypeKind, FieldInfo, SizeKind, VariantInfo};
@@ -2314,13 +2313,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.lang_items().pin_type().require(&tcx, 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.lang_items().gen_state().require(&tcx, None);
                     let state_adt_ref = tcx.adt_def(state_did);
                     let state_substs = tcx.intern_substs(&[
                         sig.yield_ty.into(),
diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs
index 93ef73171993c..16c916076370e 100644
--- a/src/librustc_middle/ty/mod.rs
+++ b/src/librustc_middle/ty/mod.rs
@@ -30,7 +30,6 @@ 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::{Constness, Node};
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_macros::HashStable;
@@ -2084,13 +2083,13 @@ impl<'tcx> AdtDef {
         if attr::contains_name(&attrs, sym::fundamental) {
             flags |= AdtFlags::IS_FUNDAMENTAL;
         }
-        if Some(did) == tcx.lang_items().phantom_data() {
+        if tcx.lang_items().phantom_data().has_def_id(did) {
             flags |= AdtFlags::IS_PHANTOM_DATA;
         }
-        if Some(did) == tcx.lang_items().owned_box() {
+        if tcx.lang_items().owned_box().has_def_id(did) {
             flags |= AdtFlags::IS_BOX;
         }
-        if Some(did) == tcx.lang_items().manually_drop() {
+        if tcx.lang_items().manually_drop().has_def_id(did) {
             flags |= AdtFlags::IS_MANUALLY_DROP;
         }
 
@@ -2432,9 +2431,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.lang_items().fn_trait().require(&tcx, None),
+            ClosureKind::FnMut => tcx.lang_items().fn_mut_trait().require(&tcx, None),
+            ClosureKind::FnOnce => tcx.lang_items().fn_once_trait().require(&tcx, None),
         }
     }
 
diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs
index 17203fcce5e59..5581a6ee6f39d 100644
--- a/src/librustc_middle/ty/print/pretty.rs
+++ b/src/librustc_middle/ty/print/pretty.rs
@@ -575,7 +575,8 @@ pub trait PrettyPrinter<'tcx>:
                     for predicate in bounds.predicates {
                         if let Some(trait_ref) = predicate.to_opt_poly_trait_ref() {
                             // Don't print +Sized, but rather +?Sized if absent.
-                            if Some(trait_ref.def_id()) == self.tcx().lang_items().sized_trait() {
+                            if self.tcx().lang_items().sized_trait().has_def_id(trait_ref.def_id())
+                            {
                                 is_sized = true;
                                 continue;
                             }
diff --git a/src/librustc_middle/ty/util.rs b/src/librustc_middle/ty/util.rs
index 47110be53b252..ace045073d981 100644
--- a/src/librustc_middle/ty/util.rs
+++ b/src/librustc_middle/ty/util.rs
@@ -17,6 +17,7 @@ use rustc_errors::ErrorReported;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
+use rustc_hir::LangItemRecord;
 use rustc_macros::HashStable;
 use rustc_span::Span;
 use rustc_target::abi::{Integer, Size, TargetDataLayout};
@@ -344,7 +345,10 @@ impl<'tcx> TyCtxt<'tcx> {
         adt_did: DefId,
         validate: &mut dyn FnMut(Self, DefId) -> Result<(), ErrorReported>,
     ) -> Option<ty::Destructor> {
-        let drop_trait = self.lang_items().drop_trait()?;
+        let drop_trait = match self.lang_items().drop_trait() {
+            LangItemRecord::Present(def_id) => def_id,
+            _ => return None,
+        };
         self.ensure().coherent_trait(drop_trait);
 
         let mut dtor_did = None;
diff --git a/src/librustc_mir/borrow_check/diagnostics/mod.rs b/src/librustc_mir/borrow_check/diagnostics/mod.rs
index 04f48cd658230..c8ef241be7dd3 100644
--- a/src/librustc_mir/borrow_check/diagnostics/mod.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/mod.rs
@@ -90,7 +90,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         } = &terminator.kind
         {
             debug!("add_moved_or_invoked_closure_note: id={:?}", id);
-            if self.infcx.tcx.parent(id) == self.infcx.tcx.lang_items().fn_once_trait() {
+            if self
+                .infcx
+                .tcx
+                .parent(id)
+                .map_or(false, |id| self.infcx.tcx.lang_items().fn_once_trait().has_def_id(id))
+            {
                 let closure = match args.first() {
                     Some(Operand::Copy(ref place)) | Some(Operand::Move(ref place))
                         if target == place.local_or_deref_local() =>
@@ -725,12 +730,12 @@ impl BorrowedContentSource<'tcx> {
                 let trait_id = tcx.trait_of_item(def_id)?;
 
                 let lang_items = tcx.lang_items();
-                if Some(trait_id) == lang_items.deref_trait()
-                    || Some(trait_id) == lang_items.deref_mut_trait()
+                if lang_items.deref_trait().has_def_id(trait_id)
+                    || lang_items.deref_mut_trait().has_def_id(trait_id)
                 {
                     Some(BorrowedContentSource::OverloadedDeref(substs.type_at(0)))
-                } else if Some(trait_id) == lang_items.index_trait()
-                    || Some(trait_id) == lang_items.index_mut_trait()
+                } else if lang_items.index_trait().has_def_id(trait_id)
+                    || lang_items.index_mut_trait().has_def_id(trait_id)
                 {
                     Some(BorrowedContentSource::OverloadedIndex(substs.type_at(0)))
                 } else {
@@ -816,7 +821,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
             if let [Operand::Move(self_place), ..] = **args {
                 if self_place.as_local() == Some(target_temp) {
-                    let is_fn_once = tcx.parent(method_did) == tcx.lang_items().fn_once_trait();
+                    let is_fn_once = tcx
+                        .parent(method_did)
+                        .map_or(false, |id| tcx.lang_items().fn_once_trait().has_def_id(id));
                     let fn_call_span = *fn_span;
 
                     let self_arg = tcx.fn_arg_names(method_did)[0];
diff --git a/src/librustc_mir/borrow_check/type_check/mod.rs b/src/librustc_mir/borrow_check/type_check/mod.rs
index 0e35cafb9f3e9..dfd5a5f94f828 100644
--- a/src/librustc_mir/borrow_check/type_check/mod.rs
+++ b/src/librustc_mir/borrow_check/type_check/mod.rs
@@ -10,7 +10,6 @@ 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_index::vec::{Idx, IndexVec};
 use rustc_infer::infer::canonical::QueryRegionConstraints;
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
@@ -507,7 +506,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.lang_items().copy_trait().require(&tcx, Some(self.last_span)),
                 substs: tcx.mk_substs_trait(place_ty.ty, &[]),
             };
 
@@ -1474,7 +1473,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.lang_items().sized_trait().require(&tcx, Some(self.last_span)),
                         substs: tcx.mk_substs_trait(place_ty, &[]),
                     };
                     self.prove_trait_ref(
@@ -2025,10 +2024,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                                     ty::PredicateKind::Trait(
                                         ty::Binder::bind(ty::TraitPredicate {
                                             trait_ref: ty::TraitRef::new(
-                                                self.tcx().require_lang_item(
-                                                    CopyTraitLangItem,
-                                                    Some(self.last_span),
-                                                ),
+                                                tcx.lang_items()
+                                                    .copy_trait()
+                                                    .require(&tcx, Some(self.last_span)),
                                                 tcx.mk_substs_trait(ty, &[]),
                                             ),
                                         }),
@@ -2053,7 +2051,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.lang_items().sized_trait().require(&tcx, Some(self.last_span)),
                     substs: tcx.mk_substs_trait(ty, &[]),
                 };
 
@@ -2151,10 +2149,10 @@ 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
+                                .lang_items()
+                                .coerce_unsized_trait()
+                                .require(&tcx, 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 3003f4639d9fa..3ef648e78aa36 100644
--- a/src/librustc_mir/borrow_check/universal_regions.rs
+++ b/src/librustc_mir/borrow_check/universal_regions.rs
@@ -17,7 +17,6 @@ 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::{BodyOwnerKind, HirId};
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_infer::infer::{InferCtxt, NLLRegionVariableOrigin};
@@ -455,10 +454,12 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
         // (as it's created inside the body itself, not passed in from outside).
         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,
-                    Some(self.infcx.tcx.def_span(self.mir_def_id)),
-                );
+                let va_list_did = self
+                    .infcx
+                    .tcx
+                    .lang_items()
+                    .va_list()
+                    .require(&self.infcx.tcx, Some(self.infcx.tcx.def_span(self.mir_def_id)));
                 let region = self
                     .infcx
                     .tcx
diff --git a/src/librustc_mir/const_eval/machine.rs b/src/librustc_mir/const_eval/machine.rs
index dc13126df0e4c..4ac2544c9d392 100644
--- a/src/librustc_mir/const_eval/machine.rs
+++ b/src/librustc_mir/const_eval/machine.rs
@@ -69,8 +69,8 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
         args: &[OpTy<'tcx>],
     ) -> InterpResult<'tcx> {
         let def_id = instance.def_id();
-        if Some(def_id) == self.tcx.lang_items().panic_fn()
-            || Some(def_id) == self.tcx.lang_items().begin_panic_fn()
+        if self.tcx.lang_items().panic_fn().has_def_id(def_id)
+            || self.tcx.lang_items().begin_panic_fn().has_def_id(def_id)
         {
             // &'static str
             assert!(args.len() == 1);
diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs
index 3c724c79b4082..3860a4d545e6f 100644
--- a/src/librustc_mir/interpret/intern.rs
+++ b/src/librustc_mir/interpret/intern.rs
@@ -166,7 +166,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: CompileTimeMachine<'mir, 'tcx>> ValueVisitor<'mir
         fields: impl Iterator<Item = InterpResult<'tcx, Self::V>>,
     ) -> InterpResult<'tcx> {
         if let Some(def) = mplace.layout.ty.ty_adt_def() {
-            if Some(def.did) == self.ecx.tcx.lang_items().unsafe_cell_type() {
+            if self.ecx.tcx.lang_items().unsafe_cell_type().has_def_id(def.did) {
                 if self.mode == InternMode::ConstInner && !self.ignore_interior_mut_in_const {
                     // We do not actually make this memory mutable.  But in case the user
                     // *expected* it to be mutable, make sure we error.  This is just a
diff --git a/src/librustc_mir/interpret/intrinsics/caller_location.rs b/src/librustc_mir/interpret/intrinsics/caller_location.rs
index 9adef8c43c7c8..6d51e391be2df 100644
--- a/src/librustc_mir/interpret/intrinsics/caller_location.rs
+++ b/src/librustc_mir/interpret/intrinsics/caller_location.rs
@@ -1,6 +1,5 @@
 use std::convert::TryFrom;
 
-use rustc_hir::lang_items::PanicLocationLangItem;
 use rustc_middle::mir::TerminatorKind;
 use rustc_middle::ty::subst::Subst;
 use rustc_span::{Span, Symbol};
@@ -64,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.lang_items().panic_location().require(&self.tcx.tcx, 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 36f3947d83017..1375536fc38db 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -182,7 +182,6 @@ use rustc_errors::ErrorReported;
 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_index::bit_set::GrowableBitSet;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::{AllocId, ConstValue};
@@ -419,7 +418,7 @@ fn check_recursion_limit<'tcx>(
     let recursion_depth = recursion_depths.get(&def_id).cloned().unwrap_or(0);
     debug!(" => recursion depth={}", recursion_depth);
 
-    let adjusted_recursion_depth = if Some(def_id) == tcx.lang_items().drop_in_place_fn() {
+    let adjusted_recursion_depth = if tcx.lang_items().drop_in_place_fn().has_def_id(def_id) {
         // HACK: drop_in_place creates tight monomorphization loops. Give
         // it more margin.
         recursion_depth / 4
@@ -580,7 +579,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.lang_items().exchange_malloc_fn().require(&tcx, None);
                 let instance = Instance::mono(tcx, exchange_malloc_fn_def_id);
                 if should_monomorphize_locally(tcx, &instance) {
                     self.output.push(create_fn_mono_item(instance));
@@ -1066,10 +1065,7 @@ impl RootCollector<'_, 'v> {
             _ => return,
         };
 
-        let start_def_id = match self.tcx.lang_items().require(StartFnLangItem) {
-            Ok(s) => s,
-            Err(err) => self.tcx.sess.fatal(&err),
-        };
+        let start_def_id = self.tcx.lang_items().start_fn().require(&self.tcx, None);
         let main_ret_ty = self.tcx.fn_sig(main_def_id).output();
 
         // Given that `main()` has no arguments,
diff --git a/src/librustc_mir/monomorphize/mod.rs b/src/librustc_mir/monomorphize/mod.rs
index 76c1c465a8be0..3338db347243d 100644
--- a/src/librustc_mir/monomorphize/mod.rs
+++ b/src/librustc_mir/monomorphize/mod.rs
@@ -2,8 +2,6 @@ use rustc_middle::traits;
 use rustc_middle::ty::adjustment::CustomCoerceUnsized;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 
-use rustc_hir::lang_items::CoerceUnsizedTraitLangItem;
-
 pub mod collector;
 pub mod partitioning;
 
@@ -12,7 +10,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.lang_items().coerce_unsized_trait().require(&tcx, None);
 
     let trait_ref = ty::Binder::bind(ty::TraitRef {
         def_id,
diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs
index db1ea72c0a531..7d0434a5ae680 100644
--- a/src/librustc_mir/monomorphize/partitioning.rs
+++ b/src/librustc_mir/monomorphize/partitioning.rs
@@ -340,7 +340,7 @@ fn mono_item_visibility(
     //        from the `main` symbol we'll generate later.
     //
     //        This may be fixable with a new `InstanceDef` perhaps? Unsure!
-    if tcx.lang_items().start_fn() == Some(def_id) {
+    if tcx.lang_items().start_fn().has_def_id(def_id) {
         *can_be_internalized = false;
         return Visibility::Hidden;
     }
@@ -734,7 +734,9 @@ fn characteristic_def_id_of_mono_item<'tcx>(
 
             if let Some(impl_def_id) = tcx.impl_of_method(def_id) {
                 if tcx.sess.opts.incremental.is_some()
-                    && tcx.trait_id_of_impl(impl_def_id) == tcx.lang_items().drop_trait()
+                    && tcx
+                        .trait_id_of_impl(impl_def_id)
+                        .map_or(false, |id| tcx.lang_items().drop_trait().has_def_id(id))
                 {
                     // Put `Drop::drop` into the same cgu as `drop_in_place`
                     // since `drop_in_place` is the only thing that can
diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs
index 71fff85153141..36e7df1d7e1d3 100644
--- a/src/librustc_mir/shim.rs
+++ b/src/librustc_mir/shim.rs
@@ -1,6 +1,5 @@
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_hir::lang_items::FnMutTraitLangItem;
 use rustc_middle::mir::*;
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::subst::{InternalSubsts, Subst};
@@ -71,7 +70,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.lang_items().fn_mut_trait().require(&tcx, None);
             let call_mut = tcx
                 .associated_items(fn_mut)
                 .in_definition_order()
diff --git a/src/librustc_mir/transform/check_consts/mod.rs b/src/librustc_mir/transform/check_consts/mod.rs
index e4aa88e3c20a7..41dd10cc60fca 100644
--- a/src/librustc_mir/transform/check_consts/mod.rs
+++ b/src/librustc_mir/transform/check_consts/mod.rs
@@ -53,5 +53,6 @@ impl ConstCx<'mir, 'tcx> {
 
 /// Returns `true` if this `DefId` points to one of the official `panic` lang items.
 pub fn is_lang_panic_fn(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
-    Some(def_id) == tcx.lang_items().panic_fn() || Some(def_id) == tcx.lang_items().begin_panic_fn()
+    tcx.lang_items().panic_fn().has_def_id(def_id)
+        || tcx.lang_items().begin_panic_fn().has_def_id(def_id)
 }
diff --git a/src/librustc_mir/transform/check_consts/qualifs.rs b/src/librustc_mir/transform/check_consts/qualifs.rs
index 936c1a84e142e..5b6caaeb3d70a 100644
--- a/src/librustc_mir/transform/check_consts/qualifs.rs
+++ b/src/librustc_mir/transform/check_consts/qualifs.rs
@@ -83,7 +83,7 @@ impl Qualif for HasMutInterior {
     fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, _: SubstsRef<'tcx>) -> bool {
         // Exactly one type, `UnsafeCell`, has the `HasMutInterior` qualif inherently.
         // It arises structurally for all other types.
-        Some(adt.did) == cx.tcx.lang_items().unsafe_cell_type()
+        cx.tcx.lang_items().unsafe_cell_type().has_def_id(adt.did)
     }
 }
 
diff --git a/src/librustc_mir/transform/check_consts/validation.rs b/src/librustc_mir/transform/check_consts/validation.rs
index 35a8df62cb83a..f0fcac04a9c27 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 as hir;
 use rustc_hir::{def_id::DefId, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
@@ -666,7 +666,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.lang_items().sync_trait().require(&tcx, 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 c8702eeae1d5b..3aa874f7684a5 100644
--- a/src/librustc_mir/transform/generator.rs
+++ b/src/librustc_mir/transform/generator.rs
@@ -61,7 +61,6 @@ 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_index::bit_set::{BitMatrix, BitSet};
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_middle::mir::visit::{MutVisitor, PlaceContext};
@@ -382,7 +381,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.lang_items().pin_type().require(&tcx, 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);
@@ -1227,7 +1226,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.lang_items().gen_state().require(&tcx, 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/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs
index caf6c7715a9e1..5bf29935fd9f0 100644
--- a/src/librustc_mir/transform/qualify_min_const_fn.rs
+++ b/src/librustc_mir/transform/qualify_min_const_fn.rs
@@ -40,7 +40,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -
                     bug!("subtype predicate on function: {:#?}", predicate)
                 }
                 &ty::PredicateKind::Trait(pred, constness) => {
-                    if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
+                    if tcx.lang_items().sized_trait().has_def_id(pred.def_id()) {
                         continue;
                     }
                     match pred.skip_binder().self_ty().kind {
@@ -130,7 +130,7 @@ fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span, fn_def_id: DefId) -> Mc
                             ));
                         }
                         ty::ExistentialPredicate::Trait(trait_ref) => {
-                            if Some(trait_ref.def_id) != tcx.lang_items().sized_trait() {
+                            if !tcx.lang_items().sized_trait().has_def_id(trait_ref.def_id) {
                                 return Err((
                                     span,
                                     "trait bounds other than `Sized` \
diff --git a/src/librustc_mir/util/elaborate_drops.rs b/src/librustc_mir/util/elaborate_drops.rs
index 5f55a812a4e0d..5e2267725e2dd 100644
--- a/src/librustc_mir/util/elaborate_drops.rs
+++ b/src/librustc_mir/util/elaborate_drops.rs
@@ -1,6 +1,5 @@
 use crate::util::patch::MirPatch;
 use rustc_hir as hir;
-use rustc_hir::lang_items::{BoxFreeFnLangItem, DropTraitLangItem};
 use rustc_index::vec::Idx;
 use rustc_middle::mir::*;
 use rustc_middle::traits::Reveal;
@@ -447,7 +446,7 @@ where
         }
 
         let skip_contents =
-            adt.is_union() || Some(adt.did) == self.tcx().lang_items().manually_drop();
+            adt.is_union() || self.tcx().lang_items().manually_drop().has_def_id(adt.did);
         let contents_drop = if skip_contents {
             (self.succ, self.unwind)
         } else {
@@ -613,7 +612,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.lang_items().drop_trait().require(&tcx, 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 +970,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.lang_items().box_free_fn().require(&tcx, 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 3e7bfc7d59b9b..63c06604c5f3a 100644
--- a/src/librustc_mir_build/build/matches/test.rs
+++ b/src/librustc_mir_build/build/matches/test.rs
@@ -362,8 +362,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);
 
@@ -417,7 +415,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().lang_items().eq_trait().require(&self.hir.tcx(), None);
         let method = self.hir.trait_method(eq_def_id, sym::eq, deref_ty, &[deref_ty.into()]);
 
         let bool_ty = self.hir.bool_ty();
diff --git a/src/librustc_mir_build/build/mod.rs b/src/librustc_mir_build/build/mod.rs
index e2cf1bce733d6..af18f599c6067 100644
--- a/src/librustc_mir_build/build/mod.rs
+++ b/src/librustc_mir_build/build/mod.rs
@@ -6,7 +6,6 @@ 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::{GeneratorKind, HirIdMap, Node};
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -128,7 +127,7 @@ fn mir_build(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Body<'_> {
                 // (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));
+                        tcx.lang_items().va_list().require(&tcx, Some(arg.span));
 
                     tcx.type_of(va_list_did).subst(tcx, &[tcx.lifetimes.re_erased.into()])
                 } else {
diff --git a/src/librustc_mir_build/hair/pattern/const_to_pat.rs b/src/librustc_mir_build/hair/pattern/const_to_pat.rs
index 1aed8e844b60b..bd6aa3bb39d72 100644
--- a/src/librustc_mir_build/hair/pattern/const_to_pat.rs
+++ b/src/librustc_mir_build/hair/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().lang_items().eq_trait().require(&self.tcx(), Some(self.span));
                     let obligation: PredicateObligation<'_> = predicate_for_trait_def(
                         self.tcx(),
                         self.param_env,
diff --git a/src/librustc_passes/lang_items.rs b/src/librustc_passes/lang_items.rs
index 779fb8039d157..a1552f5b8a68b 100644
--- a/src/librustc_passes/lang_items.rs
+++ b/src/librustc_passes/lang_items.rs
@@ -17,7 +17,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::itemlikevisit::ItemLikeVisitor;
 use rustc_hir::lang_items::{extract, ITEM_REFS};
-use rustc_hir::{LangItem, LanguageItems, Target};
+use rustc_hir::{LangItem, LangItemRecord, LanguageItems, Target};
 
 use rustc_middle::ty::query::Providers;
 
@@ -87,7 +87,7 @@ impl LanguageItemCollector<'tcx> {
 
     fn collect_item(&mut self, item_index: usize, item_def_id: DefId) {
         // Check for duplicates.
-        if let Some(original_def_id) = self.items.items[item_index] {
+        if let LangItemRecord::Present(original_def_id) = self.items.items[item_index] {
             if original_def_id != item_def_id {
                 let name = LangItem::from_u32(item_index as u32).unwrap().name();
                 let mut err = match self.tcx.hir().span_if_local(item_def_id) {
@@ -138,7 +138,7 @@ impl LanguageItemCollector<'tcx> {
         }
 
         // Matched.
-        self.items.items[item_index] = Some(item_def_id);
+        self.items.items[item_index] = LangItemRecord::Present(item_def_id);
     }
 }
 
diff --git a/src/librustc_passes/reachable.rs b/src/librustc_passes/reachable.rs
index c9a4428c007aa..0c623579de999 100644
--- a/src/librustc_passes/reachable.rs
+++ b/src/librustc_passes/reachable.rs
@@ -12,7 +12,7 @@ use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::itemlikevisit::ItemLikeVisitor;
-use rustc_hir::{HirIdSet, Node};
+use rustc_hir::{HirIdSet, LangItemRecord, Node};
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::middle::privacy;
 use rustc_middle::ty::query::Providers;
@@ -394,7 +394,7 @@ fn reachable_set<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> &'tcx HirIdSet
     //         exported.
     reachable_context.worklist.extend(access_levels.map.iter().map(|(id, _)| *id));
     for item in tcx.lang_items().items().iter() {
-        if let Some(did) = *item {
+        if let LangItemRecord::Present(did) = *item {
             if let Some(hir_id) = did.as_local().map(|did| tcx.hir().as_local_hir_id(did)) {
                 reachable_context.worklist.push(hir_id);
             }
diff --git a/src/librustc_passes/weak_lang_items.rs b/src/librustc_passes/weak_lang_items.rs
index 96ec23692df51..9ffab5916055d 100644
--- a/src/librustc_passes/weak_lang_items.rs
+++ b/src/librustc_passes/weak_lang_items.rs
@@ -12,23 +12,15 @@ use rustc_session::config::CrateType;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 
-struct Context<'a, 'tcx> {
+struct Context<'tcx> {
     tcx: TyCtxt<'tcx>,
-    items: &'a mut lang_items::LanguageItems,
 }
 
 /// Checks the crate for usage of weak lang items, returning a vector of all the
 /// language items required by this crate, but not defined yet.
-pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>, items: &mut lang_items::LanguageItems) {
-    // These are never called by user code, they're generated by the compiler.
-    // 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);
-    }
-
+pub fn check_crate<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) {
     {
-        let mut cx = Context { tcx, items };
+        let mut cx = Context { tcx };
         tcx.hir().krate().visit_all_item_likes(&mut cx.as_deep_visitor());
     }
     verify(tcx, items);
@@ -57,7 +49,7 @@ fn verify<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) {
     }
 
     for (name, &item) in WEAK_ITEMS_REFS.iter() {
-        if missing.contains(&item) && !whitelisted(tcx, item) && items.require(item).is_err() {
+        if missing.contains(&item) && !whitelisted(tcx, item) && items.get(item).is_missing() {
             if item == lang_items::PanicImplLangItem {
                 tcx.sess.err("`#[panic_handler]` function required, but not found");
             } else if item == lang_items::OomLangItem {
@@ -69,20 +61,16 @@ fn verify<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) {
     }
 }
 
-impl<'a, 'tcx> Context<'a, 'tcx> {
+impl<'tcx> Context<'tcx> {
     fn register(&mut self, name: Symbol, span: Span) {
-        if let Some(&item) = WEAK_ITEMS_REFS.get(&name) {
-            if self.items.require(item).is_err() {
-                self.items.missing.push(item);
-            }
-        } else {
+        if WEAK_ITEMS_REFS.get(&name).is_none() {
             struct_span_err!(self.tcx.sess, span, E0264, "unknown external lang item: `{}`", name)
                 .emit();
         }
     }
 }
 
-impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
+impl<'tcx, 'v> Visitor<'v> for Context<'tcx> {
     type Map = intravisit::ErasedMap<'v>;
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/src/librustc_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs
index 05ef0aa0bb689..400f7cfa92682 100644
--- a/src/librustc_resolve/late/diagnostics.rs
+++ b/src/librustc_resolve/late/diagnostics.rs
@@ -1063,7 +1063,8 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
                 self.tcx.lang_items().fn_trait(),
                 self.tcx.lang_items().fn_mut_trait(),
             ]
-            .contains(&Some(did))
+            .iter()
+            .any(|it| it.has_def_id(did))
             {
                 let (span, span_type) = match &trait_ref.bound_generic_params {
                     [] => (trait_ref.span.shrink_to_lo(), ForLifetimeSpanType::BoundEmpty),
diff --git a/src/librustc_trait_selection/infer.rs b/src/librustc_trait_selection/infer.rs
index f244785b49d2f..271324871e641 100644
--- a/src/librustc_trait_selection/infer.rs
+++ b/src/librustc_trait_selection/infer.rs
@@ -2,7 +2,6 @@ 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_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::arena::ArenaAllocatable;
@@ -47,7 +46,7 @@ impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> {
             return ty.is_copy_modulo_regions(self.tcx, param_env, span);
         }
 
-        let copy_def_id = self.tcx.require_lang_item(lang_items::CopyTraitLangItem, None);
+        let copy_def_id = self.tcx.lang_items().copy_trait().require(&self.tcx, 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/mod.rs b/src/librustc_trait_selection/traits/error_reporting/mod.rs
index e5a6c9a2e391a..93c1ad8ec9152 100644
--- a/src/librustc_trait_selection/traits/error_reporting/mod.rs
+++ b/src/librustc_trait_selection/traits/error_reporting/mod.rs
@@ -285,7 +285,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         let is_from = format!("{}", trait_ref.print_only_trait_path())
                             .starts_with("std::convert::From<");
                         let is_unsize =
-                            { Some(trait_ref.def_id()) == self.tcx.lang_items().unsize_trait() };
+                            self.tcx.lang_items().unsize_trait().has_def_id(trait_ref.def_id());
                         let (message, note) = if is_try && is_from {
                             (
                                 Some(format!(
@@ -407,7 +407,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         self.suggest_semicolon_removal(&obligation, &mut err, span, &trait_ref);
                         self.note_version_mismatch(&mut err, &trait_ref);
 
-                        if Some(trait_ref.def_id()) == tcx.lang_items().try_trait() {
+                        if tcx.lang_items().try_trait().has_def_id(trait_ref.def_id()) {
                             self.suggest_await_before_try(&mut err, &obligation, &trait_ref, span);
                         }
 
@@ -1476,12 +1476,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
                 // avoid inundating the user with unnecessary errors, but we now
                 // check upstream for type errors and don't add the obligations to
                 // begin with in those cases.
-                if self
-                    .tcx
-                    .lang_items()
-                    .sized_trait()
-                    .map_or(false, |sized_id| sized_id == trait_ref.def_id())
-                {
+                if self.tcx.lang_items().sized_trait().has_def_id(trait_ref.def_id()) {
                     self.need_type_info_err(body_id, span, self_ty, ErrorCode::E0282).emit();
                     return;
                 }
@@ -1702,13 +1697,17 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
         {
             if let (Some(generics), true) = (
                 self.tcx.hir().get_if_local(*item_def_id).as_ref().and_then(|n| n.generics()),
-                Some(pred.def_id()) == self.tcx.lang_items().sized_trait(),
+                self.tcx.lang_items().sized_trait().has_def_id(pred.def_id()),
             ) {
                 for param in generics.params {
                     if param.span == *span
                         && !param.bounds.iter().any(|bound| {
-                            bound.trait_ref().and_then(|trait_ref| trait_ref.trait_def_id())
-                                == self.tcx.lang_items().sized_trait()
+                            bound
+                                .trait_ref()
+                                .and_then(|trait_ref| trait_ref.trait_def_id())
+                                .map_or(false, |def_id| {
+                                    self.tcx.lang_items().sized_trait().has_def_id(def_id)
+                                })
                         })
                     {
                         let (span, separator) = match param.bounds {
diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
index dfd7dac72d8e1..e7037fb8f8d7b 100644
--- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
+++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
@@ -11,7 +11,6 @@ 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::{AsyncGeneratorKind, GeneratorKind, Node};
 use rustc_middle::ty::TypeckTables;
 use rustc_middle::ty::{
@@ -1914,8 +1913,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.lang_items().future_trait().require(&self.tcx, None);
 
                 let self_ty = self.resolve_vars_if_possible(&trait_ref.self_ty());
 
diff --git a/src/librustc_trait_selection/traits/object_safety.rs b/src/librustc_trait_selection/traits/object_safety.rs
index 5befc797a517a..b4c2ee201ab1c 100644
--- a/src/librustc_trait_selection/traits/object_safety.rs
+++ b/src/librustc_trait_selection/traits/object_safety.rs
@@ -16,6 +16,7 @@ use crate::traits::{self, Obligation, ObligationCause};
 use rustc_errors::{Applicability, FatalError};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
+use rustc_hir::LangItemRecord;
 use rustc_middle::ty::subst::{GenericArg, InternalSubsts, Subst};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeVisitor, WithConstness};
 use rustc_middle::ty::{Predicate, ToPredicate};
@@ -295,8 +296,8 @@ fn trait_has_sized_self(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {
 
 fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
     let sized_def_id = match tcx.lang_items().sized_trait() {
-        Some(def_id) => def_id,
-        None => {
+        LangItemRecord::Present(def_id) => def_id,
+        _ => {
             return false; /* No Sized trait, can't require it! */
         }
     };
@@ -610,12 +611,13 @@ fn receiver_is_dispatchable<'tcx>(
     debug!("receiver_is_dispatchable: method = {:?}, receiver_ty = {:?}", method, receiver_ty);
 
     let traits = (tcx.lang_items().unsize_trait(), tcx.lang_items().dispatch_from_dyn_trait());
-    let (unsize_did, dispatch_from_dyn_did) = if let (Some(u), Some(cu)) = traits {
-        (u, cu)
-    } else {
-        debug!("receiver_is_dispatchable: Missing Unsize or DispatchFromDyn traits");
-        return false;
-    };
+    let (unsize_did, dispatch_from_dyn_did) =
+        if let (LangItemRecord::Present(u), LangItemRecord::Present(cu)) = traits {
+            (u, cu)
+        } else {
+            debug!("receiver_is_dispatchable: Missing Unsize or DispatchFromDyn traits");
+            return false;
+        };
 
     // the type `U` in the query
     // use a bogus type parameter to mimic a forall(U) query using u32::MAX for now.
diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs
index ed108613bfa23..3a1b5006df1df 100644
--- a/src/librustc_trait_selection/traits/project.rs
+++ b/src/librustc_trait_selection/traits/project.rs
@@ -23,7 +23,6 @@ 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::{FnOnceTraitLangItem, GeneratorTraitLangItem};
 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder};
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::util::IntTypeExt;
@@ -1276,7 +1275,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.lang_items().gen_trait().require(&tcx, None);
 
     let predicate = super::util::generator_trait_ref_and_outputs(
         tcx,
@@ -1318,7 +1317,8 @@ 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 assoc_items = tcx.associated_items(tcx.lang_items().discriminant_kind_trait().unwrap());
+    let assoc_items =
+        tcx.associated_items(tcx.lang_items().discriminant_kind_trait().require(&tcx, None));
     // FIXME: emit an error if the trait definition is wrong
     let discriminant_def_id = assoc_items.in_definition_order().next().unwrap().def_id;
 
@@ -1394,7 +1394,7 @@ fn confirm_callable_candidate<'cx, 'tcx>(
     debug!("confirm_callable_candidate({:?},{:?})", obligation, fn_sig);
 
     // the `Output` associated type is declared on `FnOnce`
-    let fn_once_def_id = tcx.require_lang_item(FnOnceTraitLangItem, None);
+    let fn_once_def_id = tcx.lang_items().fn_once_trait().require(&tcx, None);
 
     let predicate = super::util::closure_trait_ref_and_return_type(
         tcx,
diff --git a/src/librustc_trait_selection/traits/query/dropck_outlives.rs b/src/librustc_trait_selection/traits/query/dropck_outlives.rs
index d07c95270e004..458d38fa51214 100644
--- a/src/librustc_trait_selection/traits/query/dropck_outlives.rs
+++ b/src/librustc_trait_selection/traits/query/dropck_outlives.rs
@@ -114,7 +114,7 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         }
 
         ty::Adt(def, _) => {
-            if Some(def.did) == tcx.lang_items().manually_drop() {
+            if tcx.lang_items().manually_drop().has_def_id(def.did) {
                 // `ManuallyDrop` never has a dtor.
                 true
             } else {
diff --git a/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs b/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs
index 5c8719da14e6f..7aeee931fe8d2 100644
--- a/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs
+++ b/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs
@@ -1,5 +1,6 @@
 use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::Fallible;
+use rustc_hir::LangItemRecord;
 use rustc_middle::ty::{self, ParamEnvAnd, TyCtxt};
 
 pub use rustc_middle::traits::query::type_op::ProvePredicate;
@@ -16,7 +17,7 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> {
         // we have to prove. No need to canonicalize and all that for
         // such cases.
         if let ty::PredicateKind::Trait(trait_ref, _) = key.value.predicate.kind() {
-            if let Some(sized_def_id) = tcx.lang_items().sized_trait() {
+            if let LangItemRecord::Present(sized_def_id) = tcx.lang_items().sized_trait() {
                 if trait_ref.def_id() == sized_def_id {
                     if trait_ref.skip_binder().self_ty().is_trivially_sized(tcx) {
                         return Some(());
diff --git a/src/librustc_trait_selection/traits/select/candidate_assembly.rs b/src/librustc_trait_selection/traits/select/candidate_assembly.rs
index 9045451056b19..c389c44a50d16 100644
--- a/src/librustc_trait_selection/traits/select/candidate_assembly.rs
+++ b/src/librustc_trait_selection/traits/select/candidate_assembly.rs
@@ -96,7 +96,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let def_id = obligation.predicate.def_id();
         let lang_items = self.tcx().lang_items();
 
-        if lang_items.copy_trait() == Some(def_id) {
+        if lang_items.copy_trait().has_def_id(def_id) {
             debug!("obligation self ty is {:?}", obligation.predicate.skip_binder().self_ty());
 
             // User-defined copy impls are permitted, but only for
@@ -106,18 +106,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // For other types, we'll use the builtin rules.
             let copy_conditions = self.copy_clone_conditions(obligation);
             self.assemble_builtin_bound_candidates(copy_conditions, &mut candidates)?;
-        } else if lang_items.discriminant_kind_trait() == Some(def_id) {
+        } else if lang_items.discriminant_kind_trait().has_def_id(def_id) {
             // `DiscriminantKind` is automatically implemented for every type.
             candidates.vec.push(DiscriminantKindCandidate);
-        } else if lang_items.sized_trait() == Some(def_id) {
+        } else if lang_items.sized_trait().has_def_id(def_id) {
             // Sized is never implementable by end-users, it is
             // always automatically computed.
             let sized_conditions = self.sized_conditions(obligation);
             self.assemble_builtin_bound_candidates(sized_conditions, &mut candidates)?;
-        } else if lang_items.unsize_trait() == Some(def_id) {
+        } else if lang_items.unsize_trait().has_def_id(def_id) {
             self.assemble_candidates_for_unsizing(obligation, &mut candidates);
         } else {
-            if lang_items.clone_trait() == Some(def_id) {
+            if lang_items.clone_trait().has_def_id(def_id) {
                 // Same builtin conditions as `Copy`, i.e., every type which has builtin support
                 // for `Copy` also has builtin support for `Clone`, and tuples/arrays of `Clone`
                 // types have builtin support for `Clone`.
@@ -213,7 +213,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         obligation: &TraitObligation<'tcx>,
         candidates: &mut SelectionCandidateSet<'tcx>,
     ) -> Result<(), SelectionError<'tcx>> {
-        if self.tcx().lang_items().gen_trait() != Some(obligation.predicate.def_id()) {
+        if !self.tcx().lang_items().gen_trait().has_def_id(obligation.predicate.def_id()) {
             return Ok(());
         }
 
@@ -401,7 +401,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     candidates.ambiguous = true;
                 }
                 ty::Generator(_, _, movability)
-                    if self.tcx().lang_items().unpin_trait() == Some(def_id) =>
+                    if self.tcx().lang_items().unpin_trait().has_def_id(def_id) =>
                 {
                     match movability {
                         hir::Movability::Static => {
diff --git a/src/librustc_trait_selection/traits/select/confirmation.rs b/src/librustc_trait_selection/traits/select/confirmation.rs
index f8d26c06a219d..0ca695f472147 100644
--- a/src/librustc_trait_selection/traits/select/confirmation.rs
+++ b/src/librustc_trait_selection/traits/select/confirmation.rs
@@ -7,7 +7,6 @@
 //! [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_index::bit_set::GrowableBitSet;
 use rustc_infer::infer::InferOk;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst, SubstsRef};
@@ -161,11 +160,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let lang_items = self.tcx().lang_items();
         let obligations = if has_nested {
             let trait_def = obligation.predicate.def_id();
-            let conditions = if Some(trait_def) == lang_items.sized_trait() {
+            let conditions = if lang_items.sized_trait().has_def_id(trait_def) {
                 self.sized_conditions(obligation)
-            } else if Some(trait_def) == lang_items.copy_trait() {
+            } else if lang_items.copy_trait().has_def_id(trait_def) {
                 self.copy_clone_conditions(obligation)
-            } else if Some(trait_def) == lang_items.clone_trait() {
+            } else if lang_items.clone_trait().has_def_id(trait_def) {
                 self.copy_clone_conditions(obligation)
             } else {
                 bug!("unexpected builtin trait {:?}", trait_def)
@@ -684,7 +683,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.lang_items().sized_trait().require(&tcx, 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/specialize/mod.rs b/src/librustc_trait_selection/traits/specialize/mod.rs
index 2b596be954267..f65edf01e8ba6 100644
--- a/src/librustc_trait_selection/traits/specialize/mod.rs
+++ b/src/librustc_trait_selection/traits/specialize/mod.rs
@@ -495,7 +495,7 @@ fn to_pretty_impl_header(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Option<String>
 
     for (p, _) in predicates {
         if let Some(poly_trait_ref) = p.to_opt_poly_trait_ref() {
-            if Some(poly_trait_ref.def_id()) == sized_trait {
+            if sized_trait.has_def_id(poly_trait_ref.def_id()) {
                 types_without_default_bounds.remove(poly_trait_ref.self_ty().skip_binder());
                 continue;
             }
diff --git a/src/librustc_trait_selection/traits/structural_match.rs b/src/librustc_trait_selection/traits/structural_match.rs
index 201edf27a655c..9a6c8bdb4cbbd 100644
--- a/src/librustc_trait_selection/traits/structural_match.rs
+++ b/src/librustc_trait_selection/traits/structural_match.rs
@@ -4,7 +4,6 @@ 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_middle::ty::query::Providers;
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeFoldable, TypeVisitor};
 use rustc_span::Span;
@@ -75,7 +74,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.lang_items().structural_peq_trait().require(&infcx.tcx, Some(cause.span));
     fulfillment_cx.register_bound(
         infcx,
         ty::ParamEnv::empty(),
@@ -86,7 +85,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.lang_items().structural_teq_trait().require(&infcx.tcx, 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 1825c159ff3fb..8a6704e24388d 100644
--- a/src/librustc_trait_selection/traits/wf.rs
+++ b/src/librustc_trait_selection/traits/wf.rs
@@ -3,7 +3,6 @@ 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_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable, WithConstness};
 use rustc_span::Span;
@@ -334,7 +333,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.lang_items().sized_trait().require(&self.infcx.tcx, None),
                 substs: self.infcx.tcx.mk_substs_trait(subty, &[]),
             };
             self.out.push(traits::Obligation::new(
diff --git a/src/librustc_traits/chalk/db.rs b/src/librustc_traits/chalk/db.rs
index a2aee9b6ef74d..255985e609e5c 100644
--- a/src/librustc_traits/chalk/db.rs
+++ b/src/librustc_traits/chalk/db.rs
@@ -92,16 +92,15 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t
             .map(|(wc, _)| wc.subst(self.tcx, &bound_vars))
             .filter_map(|wc| LowerInto::<Option<chalk_ir::QuantifiedWhereClause<RustInterner<'tcx>>>>::lower_into(wc, &self.interner)).collect();
 
-        let well_known =
-            if self.tcx.lang_items().sized_trait().map(|t| def_id == t).unwrap_or(false) {
-                Some(chalk_rust_ir::WellKnownTrait::SizedTrait)
-            } else if self.tcx.lang_items().copy_trait().map(|t| def_id == t).unwrap_or(false) {
-                Some(chalk_rust_ir::WellKnownTrait::CopyTrait)
-            } else if self.tcx.lang_items().clone_trait().map(|t| def_id == t).unwrap_or(false) {
-                Some(chalk_rust_ir::WellKnownTrait::CloneTrait)
-            } else {
-                None
-            };
+        let well_known = if self.tcx.lang_items().sized_trait().has_def_id(def_id) {
+            Some(chalk_rust_ir::WellKnownTrait::SizedTrait)
+        } else if self.tcx.lang_items().copy_trait().has_def_id(def_id) {
+            Some(chalk_rust_ir::WellKnownTrait::CopyTrait)
+        } else if self.tcx.lang_items().clone_trait().has_def_id(def_id) {
+            Some(chalk_rust_ir::WellKnownTrait::CloneTrait)
+        } else {
+            None
+        };
         Arc::new(chalk_rust_ir::TraitDatum {
             id: trait_id,
             binders: chalk_ir::Binders::new(
@@ -440,33 +439,13 @@ impl<'tcx> chalk_solve::RustIrDatabase<RustInterner<'tcx>> for RustIrDatabase<'t
         well_known_trait: chalk_rust_ir::WellKnownTrait,
     ) -> Option<chalk_ir::TraitId<RustInterner<'tcx>>> {
         use chalk_rust_ir::WellKnownTrait::*;
-        let t = match well_known_trait {
-            SizedTrait => self
-                .tcx
-                .lang_items()
-                .sized_trait()
-                .map(|t| chalk_ir::TraitId(RustDefId::Trait(t)))
-                .unwrap(),
-            CopyTrait => self
-                .tcx
-                .lang_items()
-                .copy_trait()
-                .map(|t| chalk_ir::TraitId(RustDefId::Trait(t)))
-                .unwrap(),
-            CloneTrait => self
-                .tcx
-                .lang_items()
-                .clone_trait()
-                .map(|t| chalk_ir::TraitId(RustDefId::Trait(t)))
-                .unwrap(),
-            DropTrait => self
-                .tcx
-                .lang_items()
-                .drop_trait()
-                .map(|t| chalk_ir::TraitId(RustDefId::Trait(t)))
-                .unwrap(),
+        let lang_record = match well_known_trait {
+            SizedTrait => self.tcx.lang_items().sized_trait(),
+            CopyTrait => self.tcx.lang_items().copy_trait(),
+            CloneTrait => self.tcx.lang_items().clone_trait(),
+            DropTrait => self.tcx.lang_items().drop_trait(),
         };
-        Some(t)
+        Some(chalk_ir::TraitId(RustDefId::Trait(lang_record.require(&self.tcx, None))))
     }
 }
 
diff --git a/src/librustc_ty/common_traits.rs b/src/librustc_ty/common_traits.rs
index 265b811571afe..95d5ad247edbd 100644
--- a/src/librustc_ty/common_traits.rs
+++ b/src/librustc_ty/common_traits.rs
@@ -24,7 +24,7 @@ fn is_item_raw<'tcx>(
     item: lang_items::LangItem,
 ) -> bool {
     let (param_env, ty) = query.into_parts();
-    let trait_def_id = tcx.require_lang_item(item, None);
+    let trait_def_id = tcx.lang_items().get(item).require(&tcx, None);
     tcx.infer_ctxt().enter(|infcx| {
         traits::type_known_to_meet_bound_modulo_regions(
             &infcx,
diff --git a/src/librustc_ty/instance.rs b/src/librustc_ty/instance.rs
index 0acf769168137..23667ce0c25bf 100644
--- a/src/librustc_ty/instance.rs
+++ b/src/librustc_ty/instance.rs
@@ -35,7 +35,7 @@ fn resolve_instance<'tcx>(
                 debug!(" => intrinsic");
                 ty::InstanceDef::Intrinsic(def_id)
             }
-            ty::FnDef(def_id, substs) if Some(def_id) == tcx.lang_items().drop_in_place_fn() => {
+            ty::FnDef(def_id, substs) if tcx.lang_items().drop_in_place_fn().has_def_id(def_id) => {
                 let ty = substs.type_at(0);
 
                 if ty.needs_drop(tcx, param_env) {
@@ -210,7 +210,7 @@ fn resolve_associated_item<'tcx>(
             Some(Instance { def: ty::InstanceDef::Virtual(def_id, index), substs: rcvr_substs })
         }
         traits::ImplSourceBuiltin(..) => {
-            if Some(trait_ref.def_id) == tcx.lang_items().clone_trait() {
+            if tcx.lang_items().clone_trait().has_def_id(trait_ref.def_id) {
                 // FIXME(eddyb) use lang items for methods instead of names.
                 let name = tcx.item_name(def_id);
                 if name == sym::clone {
diff --git a/src/librustc_ty/ty.rs b/src/librustc_ty/ty.rs
index cf70a845af0aa..597ec31dc4efe 100644
--- a/src/librustc_ty/ty.rs
+++ b/src/librustc_ty/ty.rs
@@ -1,6 +1,7 @@
 use rustc_data_structures::svh::Svh;
 use rustc_hir as hir;
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
+use rustc_hir::LangItemRecord;
 use rustc_middle::hir::map as hir_map;
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt, WithConstness};
@@ -53,7 +54,7 @@ fn sized_constraint_for_ty<'tcx>(
             // it on the impl.
 
             let sized_trait = match tcx.lang_items().sized_trait() {
-                Some(x) => x,
+                LangItemRecord::Present(x) => x,
                 _ => return vec![ty],
             };
             let sized_predicate = ty::Binder::dummy(ty::TraitRef {
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index 7cdcb2face823..77b8da7c4b89e 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -17,8 +17,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::{Constness, GenericArg, GenericArgs};
+use rustc_hir::{Constness, GenericArg, GenericArgs, LangItemRecord};
 use rustc_middle::ty::subst::{self, InternalSubsts, Subst, SubstsRef};
 use rustc_middle::ty::{
     self, Const, DefIdTree, ToPredicate, Ty, TyCtxt, TypeFoldable, WithConstness,
@@ -1258,12 +1257,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             }
         }
 
-        let kind_id = tcx.lang_items().require(SizedTraitLangItem);
+        let lang_record = tcx.lang_items().sized_trait();
         match unbound {
             Some(tpb) => {
                 // FIXME(#8559) currently requires the unbound to be built-in.
-                if let Ok(kind_id) = kind_id {
-                    if tpb.path.res != Res::Def(DefKind::Trait, kind_id) {
+                if let LangItemRecord::Present(def_id) = lang_record {
+                    if tpb.path.res != Res::Def(DefKind::Trait, def_id) {
                         tcx.sess.span_warn(
                             span,
                             "default bound relaxed for a type parameter, but \
@@ -1273,7 +1272,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     }
                 }
             }
-            _ if kind_id.is_ok() => {
+            _ if lang_record.is_present() => {
                 return false;
             }
             // No lang item for `Sized`, so we can't add it as a bound.
@@ -3143,13 +3142,15 @@ impl<'tcx> Bounds<'tcx> {
     ) -> Vec<(ty::Predicate<'tcx>, Span)> {
         // If it could be sized, and is, add the `Sized` predicate.
         let sized_predicate = self.implicitly_sized.and_then(|span| {
-            tcx.lang_items().sized_trait().map(|sized| {
+            if let LangItemRecord::Present(def_id) = tcx.lang_items().sized_trait() {
                 let trait_ref = ty::Binder::bind(ty::TraitRef {
-                    def_id: sized,
+                    def_id,
                     substs: tcx.mk_substs_trait(param_ty, &[]),
                 });
-                (trait_ref.without_const().to_predicate(tcx), span)
-            })
+                Some((trait_ref.without_const().to_predicate(tcx), span))
+            } else {
+                None
+            }
         });
 
         sized_predicate
diff --git a/src/librustc_typeck/check/autoderef.rs b/src/librustc_typeck/check/autoderef.rs
index 73d4e2b78206d..10a7921d118ca 100644
--- a/src/librustc_typeck/check/autoderef.rs
+++ b/src/librustc_typeck/check/autoderef.rs
@@ -3,6 +3,7 @@ use super::{FnCtxt, Needs, PlaceOp};
 
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_infer::infer::{InferCtxt, InferOk};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::{self, TraitRef, Ty, TyCtxt, WithConstness};
@@ -114,12 +115,15 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
 
         let tcx = self.infcx.tcx;
 
-        // <ty as Deref>
-        let trait_ref = TraitRef {
-            def_id: tcx.lang_items().deref_trait()?,
-            substs: tcx.mk_substs_trait(ty, &[]),
+        let deref_trait = if let LangItemRecord::Present(def_id) = tcx.lang_items().deref_trait() {
+            def_id
+        } else {
+            return None;
         };
 
+        // <ty as Deref>
+        let trait_ref = TraitRef { def_id: deref_trait, substs: tcx.mk_substs_trait(ty, &[]) };
+
         let cause = traits::ObligationCause::misc(self.span, self.body_id);
 
         let obligation = traits::Obligation::new(
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
index 13695be83a9da..9c70cd153c6d1 100644
--- a/src/librustc_typeck/check/callee.rs
+++ b/src/librustc_typeck/check/callee.rs
@@ -7,6 +7,7 @@ use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::LangItemRecord;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::{infer, traits};
 use rustc_middle::ty::adjustment::{
@@ -27,7 +28,7 @@ pub fn check_legal_trait_for_method_call(
     receiver: Option<Span>,
     trait_id: DefId,
 ) {
-    if tcx.lang_items().drop_trait() == Some(trait_id) {
+    if tcx.lang_items().drop_trait().has_def_id(trait_id) {
         let mut err = struct_span_err!(tcx.sess, span, E0040, "explicit use of destructor method");
         err.span_label(span, "explicit destructor calls not allowed");
 
@@ -196,8 +197,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             (self.tcx.lang_items().fn_once_trait(), Ident::from_str("call_once"), false),
         ] {
             let trait_def_id = match opt_trait_def_id {
-                Some(def_id) => def_id,
-                None => continue,
+                LangItemRecord::Present(def_id) => def_id,
+                _ => continue,
             };
 
             let opt_input_types = opt_arg_exprs.map(|arg_exprs| {
diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs
index 78474dac76f67..2f8c9386dc405 100644
--- a/src/librustc_typeck/check/cast.rs
+++ b/src/librustc_typeck/check/cast.rs
@@ -35,7 +35,6 @@ use crate::type_error_struct;
 use rustc_ast::ast;
 use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported};
 use rustc_hir as hir;
-use rustc_hir::lang_items;
 use rustc_middle::ty::adjustment::AllowTwoPhase;
 use rustc_middle::ty::cast::{CastKind, CastTy};
 use rustc_middle::ty::error::TypeError;
@@ -813,7 +812,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.lang_items().sized_trait().require(&self.tcx, 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 6d09ddc925ffe..7ad20cc53ed80 100644
--- a/src/librustc_typeck/check/closure.rs
+++ b/src/librustc_typeck/check/closure.rs
@@ -5,7 +5,6 @@ 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_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::LateBoundRegionConversionTime;
 use rustc_infer::infer::{InferOk, InferResult};
@@ -246,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.lang_items().gen_trait().require(&tcx, 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");
@@ -664,7 +663,8 @@ 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.lang_items().future_trait().require(&self.tcx, 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/coercion.rs b/src/librustc_typeck/check/coercion.rs
index dd3f292fb5684..24871ed4392d5 100644
--- a/src/librustc_typeck/check/coercion.rs
+++ b/src/librustc_typeck/check/coercion.rs
@@ -54,6 +54,7 @@ use crate::astconv::AstConv;
 use crate::check::{FnCtxt, Needs};
 use rustc_errors::{struct_span_err, DiagnosticBuilder};
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::{Coercion, InferOk, InferResult};
 use rustc_middle::ty::adjustment::{
@@ -491,12 +492,13 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
         let traits =
             (self.tcx.lang_items().unsize_trait(), self.tcx.lang_items().coerce_unsized_trait());
-        let (unsize_did, coerce_unsized_did) = if let (Some(u), Some(cu)) = traits {
-            (u, cu)
-        } else {
-            debug!("missing Unsize or CoerceUnsized traits");
-            return Err(TypeError::Mismatch);
-        };
+        let (unsize_did, coerce_unsized_did) =
+            if let (LangItemRecord::Present(u), LangItemRecord::Present(cu)) = traits {
+                (u, cu)
+            } else {
+                debug!("missing Unsize or CoerceUnsized traits");
+                return Err(TypeError::Mismatch);
+            };
 
         // Note, we want to avoid unnecessary unsizing. We don't want to coerce to
         // a DST unless we have to. This currently comes out in the wash since
diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
index 019b4ca66060c..2614029962ac1 100644
--- a/src/librustc_typeck/check/demand.rs
+++ b/src/librustc_typeck/check/demand.rs
@@ -6,7 +6,6 @@ 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::{is_range_literal, Node};
 use rustc_middle::ty::adjustment::AllowTwoPhase;
 use rustc_middle::ty::{self, AssocItem, Ty, TypeAndMut};
@@ -462,7 +461,8 @@ 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.lang_items().clone_trait().require(&self.tcx, Some(sp));
                         if let ([arg], Some(true), sym::clone) = (
                             &args[..],
                             self.tables.borrow().type_dependent_def_id(expr.hir_id).map(|did| {
diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs
index bded2c695c9db..e7667bceaf544 100644
--- a/src/librustc_typeck/check/intrinsic.rs
+++ b/src/librustc_typeck/check/intrinsic.rs
@@ -5,6 +5,7 @@ use crate::require_same_types;
 
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, Ty, TyCtxt};
@@ -88,15 +89,18 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
     let name = it.ident.as_str();
 
     let mk_va_list_ty = |mutbl| {
-        tcx.lang_items().va_list().map(|did| {
-            let region = tcx.mk_region(ty::ReLateBound(ty::INNERMOST, ty::BrAnon(0)));
-            let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv);
-            let va_list_ty = tcx.type_of(did).subst(tcx, &[region.into()]);
-            (
-                tcx.mk_ref(tcx.mk_region(env_region), ty::TypeAndMut { ty: va_list_ty, mutbl }),
-                va_list_ty,
-            )
-        })
+        let did = if let LangItemRecord::Present(def_id) = tcx.lang_items().va_list() {
+            def_id
+        } else {
+            return None;
+        };
+        let region = tcx.mk_region(ty::ReLateBound(ty::INNERMOST, ty::BrAnon(0)));
+        let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv);
+        let va_list_ty = tcx.type_of(did).subst(tcx, &[region.into()]);
+        Some((
+            tcx.mk_ref(tcx.mk_region(env_region), ty::TypeAndMut { ty: va_list_ty, mutbl }),
+            va_list_ty,
+        ))
     };
 
     let (n_tps, inputs, output, unsafety) = if name.starts_with("atomic_") {
@@ -284,8 +288,9 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
             "unlikely" => (0, vec![tcx.types.bool], tcx.types.bool),
 
             "discriminant_value" => {
-                let assoc_items =
-                    tcx.associated_items(tcx.lang_items().discriminant_kind_trait().unwrap());
+                let assoc_items = tcx.associated_items(
+                    tcx.lang_items().discriminant_kind_trait().require(&tcx, None),
+                );
                 let discriminant_def_id = assoc_items.in_definition_order().next().unwrap().def_id;
 
                 (
diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs
index 8651c643cee87..72df071e547d1 100644
--- a/src/librustc_typeck/check/method/confirm.rs
+++ b/src/librustc_typeck/check/method/confirm.rs
@@ -5,6 +5,7 @@ use crate::check::{callee, FnCtxt, Needs, PlaceOp};
 use crate::hir::def_id::DefId;
 use crate::hir::GenericArg;
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_infer::infer::{self, InferOk};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref, PointerCast};
 use rustc_middle::ty::adjustment::{AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
@@ -568,8 +569,8 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         predicates: &ty::InstantiatedPredicates<'tcx>,
     ) -> Option<Span> {
         let sized_def_id = match self.tcx.lang_items().sized_trait() {
-            Some(def_id) => def_id,
-            None => return None,
+            LangItemRecord::Present(def_id) => def_id,
+            _ => return None,
         };
 
         traits::elaborate_predicates(self.tcx, predicates.predicates.iter().copied())
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
index 93bcd5cf29149..4f228a8d038b9 100644
--- a/src/librustc_typeck/check/method/probe.rs
+++ b/src/librustc_typeck/check/method/probe.rs
@@ -15,6 +15,7 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def::Namespace;
+use rustc_hir::LangItemRecord;
 use rustc_infer::infer::canonical::OriginalQueryValues;
 use rustc_infer::infer::canonical::{Canonical, QueryResponse};
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
@@ -694,8 +695,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         }
     }
 
-    fn assemble_inherent_impl_for_primitive(&mut self, lang_def_id: Option<DefId>) {
-        if let Some(impl_def_id) = lang_def_id {
+    fn assemble_inherent_impl_for_primitive(&mut self, lang_record: LangItemRecord) {
+        if let LangItemRecord::Present(impl_def_id) = lang_record {
             self.assemble_inherent_impl_probe(impl_def_id);
         }
     }
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
index 67bdd04d3715c..72ef6debd72c0 100644
--- a/src/librustc_typeck/check/method/suggest.rs
+++ b/src/librustc_typeck/check/method/suggest.rs
@@ -9,8 +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::{ExprKind, Node, QPath};
+use rustc_hir::{ExprKind, LangItemRecord, Node, QPath};
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_middle::hir::map as hir_map;
 use rustc_middle::ty::print::with_crate_prefix;
@@ -36,9 +35,9 @@ 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) {
-                    Ok(fn_once) => fn_once,
-                    Err(..) => return false,
+                let fn_once = match tcx.lang_items().fn_once_trait() {
+                    LangItemRecord::Present(fn_once) => fn_once,
+                    _ => return false,
                 };
 
                 self.autoderef(span, ty).any(|(ty, _)| {
@@ -273,10 +272,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // There are methods that are defined on the primitive types and won't be
                     // found when exploring `all_traits`, but we also need them to be acurate on
                     // our suggestions (#47759).
-                    let fund_assoc = |opt_def_id: Option<DefId>| {
-                        opt_def_id
-                            .and_then(|id| self.associated_item(id, item_name, Namespace::ValueNS))
-                            .is_some()
+                    let fund_assoc = |lang_record: LangItemRecord| {
+                        if let LangItemRecord::Present(def_id) = lang_record {
+                            self.associated_item(def_id, item_name, Namespace::ValueNS).is_some()
+                        } else {
+                            false
+                        }
                     };
                     let lang_items = tcx.lang_items();
                     let found_candidate = candidates.next().is_some()
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index b60b06567d6fa..4a1cef44b984c 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -99,10 +99,10 @@ use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, 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::PinTypeLangItem;
+use rustc_hir::{
+    ExprKind, GenericArg, HirIdMap, Item, ItemKind, LangItemRecord, Node, PatKind, QPath,
 };
-use rustc_hir::{ExprKind, GenericArg, HirIdMap, Item, ItemKind, Node, PatKind, QPath};
 use rustc_index::bit_set::BitSet;
 use rustc_index::vec::Idx;
 use rustc_infer::infer;
@@ -1329,7 +1329,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.lang_items().va_list().require(&tcx, Some(span));
         let region = fcx.next_region_var(RegionVariableOrigin::MiscVariable(span));
 
         Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
@@ -1430,7 +1430,7 @@ fn check_fn<'a, 'tcx>(
     fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
 
     // Check that the main return type implements the termination trait.
-    if let Some(term_id) = tcx.lang_items().termination() {
+    if let LangItemRecord::Present(term_id) = tcx.lang_items().termination() {
         if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
             let main_id = hir.as_local_hir_id(def_id);
             if main_id == fn_id {
@@ -1453,9 +1453,9 @@ fn check_fn<'a, 'tcx>(
     }
 
     // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
-    if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
+    if let LangItemRecord::Present(panic_impl_did) = tcx.lang_items().panic_impl() {
         if panic_impl_did == hir.local_def_id(fn_id).to_def_id() {
-            if let Some(panic_info_did) = tcx.lang_items().panic_info() {
+            if let LangItemRecord::Present(panic_info_did) = tcx.lang_items().panic_info() {
                 if declared_ret_ty.kind != ty::Never {
                     sess.span_err(decl.output.span(), "return type should be `!`");
                 }
@@ -1497,9 +1497,9 @@ fn check_fn<'a, 'tcx>(
     }
 
     // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
-    if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
+    if let LangItemRecord::Present(alloc_error_handler_did) = tcx.lang_items().oom() {
         if alloc_error_handler_did == hir.local_def_id(fn_id).to_def_id() {
-            if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
+            if let LangItemRecord::Present(alloc_layout_did) = tcx.lang_items().alloc_layout() {
                 if declared_ret_ty.kind != ty::Never {
                     sess.span_err(decl.output.span(), "return type should be `!`");
                 }
@@ -2392,7 +2392,7 @@ fn bounds_from_generic_predicates(
             ty::PredicateKind::Trait(trait_predicate, _) => {
                 let entry = types.entry(trait_predicate.skip_binder().self_ty()).or_default();
                 let def_id = trait_predicate.skip_binder().def_id();
-                if Some(def_id) != tcx.lang_items().sized_trait() {
+                if !tcx.lang_items().sized_trait().has_def_id(def_id) {
                     // Type params are `Sized` by default, do not add that restriction to the list
                     // if it is a positive requirement.
                     entry.push(trait_predicate.skip_binder().def_id());
@@ -3465,7 +3465,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.lang_items().sized_trait().require(&self.tcx, None);
             self.require_type_meets(ty, span, code, lang_item);
         }
     }
@@ -3862,7 +3862,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         None
     }
 
-    fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Ident) {
+    fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (LangItemRecord, Ident) {
         let (tr, name) = match (op, is_mut) {
             (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
             (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
@@ -3885,7 +3885,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Try Mut first, if needed.
         let (mut_tr, mut_op) = self.resolve_place_op(op, true);
         let method = match (needs, mut_tr) {
-            (Needs::MutPlace, Some(trait_did)) => {
+            (Needs::MutPlace, LangItemRecord::Present(trait_did)) => {
                 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
             }
             _ => None,
@@ -3894,7 +3894,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Otherwise, fall back to the immutable version.
         let (imm_tr, imm_op) = self.resolve_place_op(op, false);
         match (method, imm_tr) {
-            (None, Some(trait_did)) => {
+            (None, LangItemRecord::Present(trait_did)) => {
                 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
             }
             (method, _) => method,
@@ -4027,7 +4027,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
         self.obligations_for_self_ty(self_ty)
-            .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
+            .any(|(tr, _)| self.tcx.lang_items().sized_trait().has_def_id(tr.def_id()))
     }
 
     /// Generic function that factors out common logic from function calls,
@@ -5286,9 +5286,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
         let pin_did = self.tcx.lang_items().pin_type();
         match expected.kind {
-            ty::Adt(def, _) if Some(def.did) != pin_did => return false,
+            ty::Adt(def, _) if !pin_did.has_def_id(def.did) => return false,
             // This guards the `unwrap` and `mk_box` below.
-            _ if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() => return false,
+            _ if pin_did.is_missing() || self.tcx.lang_items().owned_box().is_missing() => {
+                return false;
+            }
             _ => {}
         }
         let boxed_found = self.tcx.mk_box(found);
@@ -5449,7 +5451,8 @@ 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.lang_items().future_trait().require(&self.tcx, Some(sp));
                 let item_def_id = self
                     .tcx
                     .associated_items(future_trait)
diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs
index fe50870911647..614ce72203eb1 100644
--- a/src/librustc_typeck/check/op.rs
+++ b/src/librustc_typeck/check/op.rs
@@ -4,6 +4,7 @@ use super::method::MethodCallee;
 use super::{FnCtxt, Needs};
 use rustc_errors::{self, struct_span_err, Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_middle::ty::adjustment::{
     Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability,
@@ -784,16 +785,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             lhs_ty, op, opname, trait_did
         );
 
-        let method = trait_did.and_then(|trait_did| {
-            let opname = Ident::from_str(opname);
-            self.lookup_method_in_trait(span, opname, trait_did, lhs_ty, Some(other_tys))
-        });
+        let trait_did = if let LangItemRecord::Present(trait_did) = trait_did {
+            trait_did
+        } else {
+            return Err(());
+        };
+
+        let opname = Ident::from_str(opname);
+        let method = self.lookup_method_in_trait(span, opname, trait_did, lhs_ty, Some(other_tys));
 
         match method {
             Some(ok) => {
                 let method = self.register_infer_ok_obligations(ok);
                 self.select_obligations_where_possible(false, |_| {});
-
                 Ok(method)
             }
             None => Err(()),
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
index f3297ed674347..3ac7d4ac1debb 100644
--- a/src/librustc_typeck/check/wfcheck.rs
+++ b/src/librustc_typeck/check/wfcheck.rs
@@ -7,8 +7,7 @@ use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::itemlikevisit::ParItemLikeVisitor;
-use rustc_hir::lang_items;
-use rustc_hir::ItemKind;
+use rustc_hir::{ItemKind, LangItemRecord};
 use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts, Subst};
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
@@ -385,7 +384,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.lang_items().sized_trait().require(&fcx.tcx, None),
                     traits::ObligationCause::new(
                         field.span,
                         fcx.body_id,
@@ -602,7 +601,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.lang_items().sized_trait().require(&fcx.tcx, None),
                 traits::ObligationCause::new(ty_span, fcx.body_id, traits::MiscObligation),
             );
         }
@@ -1107,7 +1106,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.lang_items().receiver_trait().require(&fcx.tcx, None);
 
     // Keep dereferencing `receiver_ty` until we get to `self_ty`.
     loop {
@@ -1230,7 +1229,7 @@ fn report_bivariance(tcx: TyCtxt<'_>, span: Span, param_name: Symbol) {
 
     let suggested_marker_id = tcx.lang_items().phantom_data();
     // Help is available only in presence of lang items.
-    let msg = if let Some(def_id) = suggested_marker_id {
+    let msg = if let LangItemRecord::Present(def_id) = suggested_marker_id {
         format!(
             "consider removing `{}`, referring to it in a field, or using a marker such as `{}`",
             param_name,
diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs
index 8c6161a626473..9c03e4b8df671 100644
--- a/src/librustc_typeck/coherence/builtin.rs
+++ b/src/librustc_typeck/coherence/builtin.rs
@@ -4,10 +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::ItemKind;
+use rustc_hir::{ItemKind, LangItemRecord};
 use rustc_infer::infer;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::{RegionckMode, TyCtxtInferExt};
@@ -34,11 +31,11 @@ struct Checker<'tcx> {
 }
 
 impl<'tcx> Checker<'tcx> {
-    fn check<F>(&self, trait_def_id: Option<DefId>, mut f: F) -> &Self
+    fn check<F>(&self, trait_record: LangItemRecord, mut f: F) -> &Self
     where
         F: FnMut(TyCtxt<'tcx>, LocalDefId),
     {
-        if Some(self.trait_def_id) == trait_def_id {
+        if trait_record.has_def_id(self.trait_def_id) {
             for &impl_id in self.tcx.hir().trait_impls(self.trait_def_id) {
                 let impl_def_id = self.tcx.hir().local_def_id(impl_id);
                 f(self.tcx, impl_def_id);
@@ -149,7 +146,8 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef
     let impl_hir_id = tcx.hir().as_local_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.lang_items().dispatch_from_dyn_trait().require(&tcx, Some(span));
 
     let source = tcx.type_of(impl_did);
     assert!(!source.has_escaping_bound_vars());
@@ -318,11 +316,12 @@ pub fn coerce_unsized_info(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedI
     let impl_hir_id = tcx.hir().as_local_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.lang_items().coerce_unsized_trait().require(&tcx, Some(span));
 
-    let unsize_trait = tcx.lang_items().require(UnsizeTraitLangItem).unwrap_or_else(|err| {
-        tcx.sess.fatal(&format!("`CoerceUnsized` implementation {}", err));
-    });
+    let unsize_trait = tcx
+        .lang_items()
+        .unsize_trait()
+        .require_with(&tcx, None, |err| format!("`CoerceUnsized` implementation {}", err));
 
     let source = tcx.type_of(impl_did);
     let trait_ref = tcx.impl_trait_ref(impl_did).unwrap();
diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs
index 93ee87f6c572e..fe3df8b6e17e2 100644
--- a/src/librustc_typeck/coherence/inherent_impls.rs
+++ b/src/librustc_typeck/coherence/inherent_impls.rs
@@ -11,6 +11,7 @@ use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::itemlikevisit::ItemLikeVisitor;
+use rustc_hir::LangItemRecord;
 use rustc_middle::ty::{self, CrateInherentImpls, TyCtxt};
 
 use rustc_ast::ast;
@@ -86,7 +87,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> {
                 self.check_primitive_impl(
                     def_id,
                     lang_items.str_impl(),
-                    lang_items.str_alloc_impl(),
+                    Some(lang_items.str_alloc_impl()),
                     "str",
                     "str",
                     item.span,
@@ -96,7 +97,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> {
                 self.check_primitive_impl(
                     def_id,
                     lang_items.slice_u8_impl(),
-                    lang_items.slice_u8_alloc_impl(),
+                    Some(lang_items.slice_u8_alloc_impl()),
                     "slice_u8",
                     "[u8]",
                     item.span,
@@ -106,7 +107,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> {
                 self.check_primitive_impl(
                     def_id,
                     lang_items.slice_impl(),
-                    lang_items.slice_alloc_impl(),
+                    Some(lang_items.slice_alloc_impl()),
                     "slice",
                     "[T]",
                     item.span,
@@ -280,7 +281,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> {
                 self.check_primitive_impl(
                     def_id,
                     lang_items.f32_impl(),
-                    lang_items.f32_runtime_impl(),
+                    Some(lang_items.f32_runtime_impl()),
                     "f32",
                     "f32",
                     item.span,
@@ -290,7 +291,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> {
                 self.check_primitive_impl(
                     def_id,
                     lang_items.f64_impl(),
-                    lang_items.f64_runtime_impl(),
+                    Some(lang_items.f64_runtime_impl()),
                     "f64",
                     "f64",
                     item.span,
@@ -345,17 +346,17 @@ impl InherentCollect<'tcx> {
     fn check_primitive_impl(
         &self,
         impl_def_id: LocalDefId,
-        lang_def_id: Option<DefId>,
-        lang_def_id2: Option<DefId>,
+        lang_record1: LangItemRecord,
+        lang_record2: Option<LangItemRecord>,
         lang: &str,
         ty: &str,
         span: Span,
     ) {
-        match (lang_def_id, lang_def_id2) {
-            (Some(lang_def_id), _) if lang_def_id == impl_def_id.to_def_id() => {
+        match (lang_record1, lang_record2) {
+            (lang_record, _) if lang_record.has_def_id(impl_def_id.to_def_id()) => {
                 // OK
             }
-            (_, Some(lang_def_id)) if lang_def_id == impl_def_id.to_def_id() => {
+            (_, Some(lang_record)) if lang_record.has_def_id(impl_def_id.to_def_id()) => {
                 // OK
             }
             _ => {
diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs
index a45a44a6801e8..14f1e99457a5e 100644
--- a/src/librustc_typeck/coherence/mod.rs
+++ b/src/librustc_typeck/coherence/mod.rs
@@ -45,11 +45,10 @@ fn enforce_trait_manually_implementable(
     impl_def_id: LocalDefId,
     trait_def_id: DefId,
 ) {
-    let did = Some(trait_def_id);
     let li = tcx.lang_items();
 
     // Disallow *all* explicit impls of `DiscriminantKind`, `Sized` and `Unsize` for now.
-    if did == li.discriminant_kind_trait() {
+    if li.discriminant_kind_trait().has_def_id(trait_def_id) {
         let span = impl_header_span(tcx, impl_def_id);
         struct_span_err!(
             tcx.sess,
@@ -62,7 +61,7 @@ fn enforce_trait_manually_implementable(
         return;
     }
 
-    if did == li.sized_trait() {
+    if li.sized_trait().has_def_id(trait_def_id) {
         let span = impl_header_span(tcx, impl_def_id);
         struct_span_err!(
             tcx.sess,
@@ -75,7 +74,7 @@ fn enforce_trait_manually_implementable(
         return;
     }
 
-    if did == li.unsize_trait() {
+    if li.unsize_trait().has_def_id(trait_def_id) {
         let span = impl_header_span(tcx, impl_def_id);
         struct_span_err!(
             tcx.sess,
@@ -109,11 +108,11 @@ fn enforce_trait_manually_implementable(
         }
     }
 
-    let trait_name = if did == li.fn_trait() {
+    let trait_name = if li.fn_trait().has_def_id(trait_def_id) {
         "Fn"
-    } else if did == li.fn_mut_trait() {
+    } else if li.fn_mut_trait().has_def_id(trait_def_id) {
         "FnMut"
-    } else if did == li.fn_once_trait() {
+    } else if li.fn_once_trait().has_def_id(trait_def_id) {
         "FnOnce"
     } else {
         return; // everything OK
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 8d8a1b4d96761..1bf565e91857e 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -201,7 +201,7 @@ fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: LocalDefId) {
             }
 
             let actual = tcx.fn_sig(main_def_id);
-            let expected_return_type = if tcx.lang_items().termination().is_some() {
+            let expected_return_type = if tcx.lang_items().termination().is_present() {
                 // we take the return type of the given main function, the real check is done
                 // in `check_fn`
                 actual.output().skip_binder()
diff --git a/src/librustc_typeck/variance/terms.rs b/src/librustc_typeck/variance/terms.rs
index 6e15485756d98..5812a5ad155fb 100644
--- a/src/librustc_typeck/variance/terms.rs
+++ b/src/librustc_typeck/variance/terms.rs
@@ -92,8 +92,8 @@ fn lang_items(tcx: TyCtxt<'_>) -> Vec<(hir::HirId, Vec<ty::Variance>)> {
     ];
 
     all.into_iter() // iterating over (Option<DefId>, Variance)
-        .filter(|&(ref d, _)| d.is_some())
-        .map(|(d, v)| (d.unwrap(), v)) // (DefId, Variance)
+        .filter(|&(ref d, _)| d.is_present())
+        .map(|(d, v)| (d.require(&tcx, None), v)) // (DefId, Variance)
         .filter_map(|(d, v)| d.as_local().map(|d| tcx.hir().as_local_hir_id(d)).map(|n| (n, v))) // (HirId, Variance)
         .collect()
 }
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index 423160f3a9e01..00b673e23e44b 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -1,6 +1,5 @@
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
-use rustc_hir::lang_items;
 use rustc_middle::ty::{self, Region, RegionVid, TypeFoldable};
 use rustc_trait_selection::traits::auto_trait::{self, AutoTraitResult};
 
@@ -454,7 +453,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.lang_items().sized_trait().require(&self.cx.tcx, None);
 
         let mut replacer = RegionReplacer { vid_to_region: &vid_to_region, tcx };
 
@@ -737,9 +736,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.lang_items().fn_trait().require(&tcx, None)
+                    || *did == tcx.lang_items().fn_mut_trait().require(&tcx, None)
+                    || *did == tcx.lang_items().fn_once_trait().require(&tcx, None)
             }
             _ => false,
         }
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 08e04f719e9ba..2311643b4db48 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -391,7 +391,7 @@ pub fn build_impl(
         clean::GenericBound::TraitBound(polyt, _) => polyt.trait_,
         clean::GenericBound::Outlives(..) => unreachable!(),
     });
-    if trait_.def_id() == tcx.lang_items().deref_trait() {
+    if trait_.def_id().map_or(false, |id| tcx.lang_items().deref_trait().has_def_id(id)) {
         super::build_deref_target_impls(cx, &trait_items, ret);
     }
     if let Some(trait_did) = trait_.def_id() {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 73fe87b05d477..0b5d9be0bf147 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -15,6 +15,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
+use rustc_hir::LangItemRecord;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_infer::infer::region_constraints::{Constraint, RegionConstraintData};
 use rustc_middle::middle::resolve_lifetime as rl;
@@ -1665,7 +1666,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
                             return None;
                         };
 
-                        if let Some(sized) = cx.tcx.lang_items().sized_trait() {
+                        if let LangItemRecord::Present(sized) = cx.tcx.lang_items().sized_trait() {
                             if trait_ref.def_id() == sized {
                                 has_sized = true;
                                 return None;
@@ -2114,7 +2115,7 @@ impl Clean<Vec<Item>> for doctree::Impl<'_> {
 
         // If this impl block is an implementation of the Deref trait, then we
         // need to try inlining the target's inherent impl blocks as well.
-        if trait_.def_id() == cx.tcx.lang_items().deref_trait() {
+        if trait_.def_id().map_or(false, |id| cx.tcx.lang_items().deref_trait().has_def_id(id)) {
             build_deref_target_impls(cx, &items, &mut ret);
         }
 
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 5c76c840b1ddd..7bb9f46331fb6 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -15,7 +15,6 @@ 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::Mutability;
 use rustc_index::vec::IndexVec;
 use rustc_middle::middle::stability;
@@ -701,7 +700,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.lang_items().sized_trait().require(&cx.tcx, 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);
@@ -717,7 +716,8 @@ impl GenericBound {
     pub fn is_sized_bound(&self, cx: &DocContext<'_>) -> bool {
         use rustc_hir::TraitBoundModifier as TBM;
         if let GenericBound::TraitBound(PolyTrait { ref trait_, .. }, TBM::None) = *self {
-            if trait_.def_id() == cx.tcx.lang_items().sized_trait() {
+            if trait_.def_id().map_or(false, |id| cx.tcx.lang_items().sized_trait().has_def_id(id))
+            {
                 return true;
             }
         }
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index c4e4802db6c07..cbe10ace54636 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -13,6 +13,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::LangItemRecord;
 use rustc_middle::mir::interpret::{sign_extend, ConstValue, Scalar};
 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
 use rustc_middle::ty::{self, DefIdTree, Ty};
@@ -26,9 +27,14 @@ pub fn krate(mut cx: &mut DocContext<'_>) -> Crate {
     let module = crate::visit_ast::RustdocVisitor::new(&mut cx).visit(krate);
 
     let mut r = cx.renderinfo.get_mut();
-    r.deref_trait_did = cx.tcx.lang_items().deref_trait();
-    r.deref_mut_trait_did = cx.tcx.lang_items().deref_mut_trait();
-    r.owned_box_did = cx.tcx.lang_items().owned_box();
+    // FIXME(doctorn) think of a better way to handle this as we don't really want to have to
+    // convert to options like this.
+    let to_option = |lang_record| {
+        if let LangItemRecord::Present(def_id) = lang_record { Some(def_id) } else { None }
+    };
+    r.deref_trait_did = to_option(cx.tcx.lang_items().deref_trait());
+    r.deref_mut_trait_did = to_option(cx.tcx.lang_items().deref_mut_trait());
+    r.owned_box_did = to_option(cx.tcx.lang_items().owned_box());
 
     let mut externs = Vec::new();
     for &cnum in cx.tcx.crates().iter() {
@@ -386,14 +392,14 @@ pub fn build_deref_target_impls(cx: &DocContext<'_>, items: &[Item], ret: &mut V
             Str => tcx.lang_items().str_impl(),
             Slice => tcx.lang_items().slice_impl(),
             Array => tcx.lang_items().slice_impl(),
-            Tuple => None,
-            Unit => None,
+            Tuple => return,
+            Unit => return,
             RawPointer => tcx.lang_items().const_ptr_impl(),
-            Reference => None,
-            Fn => None,
-            Never => None,
+            Reference => return,
+            Fn => return,
+            Never => return,
         };
-        if let Some(did) = did {
+        if let LangItemRecord::Present(did) = did {
             if !did.is_local() {
                 inline::build_impl(cx, did, None, ret);
             }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index f5b2f1bb5b178..c5d31a4b8febe 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -9,6 +9,7 @@ use rustc_hir::def::{
     PerNS, Res,
 };
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::LangItemRecord;
 use rustc_middle::ty;
 use rustc_resolve::ParentScope;
 use rustc_session::lint;
@@ -1065,7 +1066,7 @@ fn is_primitive(path_str: &str, ns: Namespace) -> Option<Res> {
 
 fn primitive_impl(cx: &DocContext<'_>, path_str: &str) -> Option<DefId> {
     let tcx = cx.tcx;
-    match path_str {
+    let lang_record = match path_str {
         "u8" => tcx.lang_items().u8_impl(),
         "u16" => tcx.lang_items().u16_impl(),
         "u32" => tcx.lang_items().u32_impl(),
@@ -1083,6 +1084,7 @@ fn primitive_impl(cx: &DocContext<'_>, path_str: &str) -> Option<DefId> {
         "str" => tcx.lang_items().str_impl(),
         "bool" => tcx.lang_items().bool_impl(),
         "char" => tcx.lang_items().char_impl(),
-        _ => None,
-    }
+        _ => return None,
+    };
+    if let LangItemRecord::Present(def_id) = lang_record { Some(def_id) } else { None }
 }
diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
index 0fdeefd79e9f2..f1c165ef86713 100644
--- a/src/librustdoc/passes/collect_trait_impls.rs
+++ b/src/librustdoc/passes/collect_trait_impls.rs
@@ -5,6 +5,7 @@ use crate::fold::DocFolder;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::LangItemRecord;
 use rustc_span::symbol::sym;
 
 pub const COLLECT_TRAIT_IMPLS: Pass = Pass {
@@ -66,7 +67,11 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate {
         lang_items.mut_slice_ptr_impl(),
     ];
 
-    for def_id in primitive_impls.iter().filter_map(|&def_id| def_id) {
+    let present_primitive_impls = primitive_impls.iter().filter_map(|lang_record| {
+        if let LangItemRecord::Present(def_id) = lang_record { Some(*def_id) } else { None }
+    });
+
+    for def_id in present_primitive_impls {
         if !def_id.is_local() {
             inline::build_impl(cx, def_id, None, &mut new_items);
 
@@ -86,7 +91,11 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate {
     // scan through included items ahead of time to splice in Deref targets to the "valid" sets
     for it in &new_items {
         if let ImplItem(Impl { ref for_, ref trait_, ref items, .. }) = it.inner {
-            if cleaner.keep_item(for_) && trait_.def_id() == cx.tcx.lang_items().deref_trait() {
+            if cleaner.keep_item(for_)
+                && trait_
+                    .def_id()
+                    .map_or(false, |id| cx.tcx.lang_items().deref_trait().has_def_id(id))
+            {
                 let target = items
                     .iter()
                     .find_map(|item| match item.inner {
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index 1cd30ae2c6381..f5bff45511b85 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -2,7 +2,7 @@ use crate::utils::{get_parent_expr, implements_trait, snippet, span_lint_and_sug
 use if_chain::if_chain;
 use rustc_ast::util::parser::{ExprPrecedence, PREC_POSTFIX, PREC_PREFIX};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, LangItemRecord};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -73,39 +73,41 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Dereferencing {
 fn lint_deref(cx: &LateContext<'_, '_>, method_name: &str, call_expr: &Expr<'_>, var_span: Span, expr_span: Span) {
     match method_name {
         "deref" => {
-            if cx
+            if let LangItemRecord::Present(def_id) = cx
                 .tcx
                 .lang_items()
                 .deref_trait()
-                .map_or(false, |id| implements_trait(cx, cx.tables.expr_ty(&call_expr), id, &[]))
             {
-                span_lint_and_sugg(
-                    cx,
-                    EXPLICIT_DEREF_METHODS,
-                    expr_span,
-                    "explicit deref method call",
-                    "try this",
-                    format!("&*{}", &snippet(cx, var_span, "..")),
-                    Applicability::MachineApplicable,
-                );
+                if implements_trait(cx, cx.tables.expr_ty(&call_expr), def_id, &[]) {
+                    span_lint_and_sugg(
+                        cx,
+                        EXPLICIT_DEREF_METHODS,
+                        expr_span,
+                        "explicit deref method call",
+                        "try this",
+                        format!("&*{}", &snippet(cx, var_span, "..")),
+                        Applicability::MachineApplicable,
+                    );
+                }
             }
         },
         "deref_mut" => {
-            if cx
+            if let LangItemRecord::Present(def_id) = cx
                 .tcx
                 .lang_items()
                 .deref_mut_trait()
-                .map_or(false, |id| implements_trait(cx, cx.tables.expr_ty(&call_expr), id, &[]))
             {
-                span_lint_and_sugg(
-                    cx,
-                    EXPLICIT_DEREF_METHODS,
-                    expr_span,
-                    "explicit deref_mut method call",
-                    "try this",
-                    format!("&mut *{}", &snippet(cx, var_span, "..")),
-                    Applicability::MachineApplicable,
-                );
+                if implements_trait(cx, cx.tables.expr_ty(&call_expr), def_id, &[]) {
+                    span_lint_and_sugg(
+                        cx,
+                        EXPLICIT_DEREF_METHODS,
+                        expr_span,
+                        "explicit deref_mut method call",
+                        "try this",
+                        format!("&mut *{}", &snippet(cx, var_span, "..")),
+                        Applicability::MachineApplicable,
+                    );
+                }
             }
         },
         _ => (),
diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs
index 3cbb8fa72f74f..4e62cc00c40c4 100644
--- a/src/tools/clippy/clippy_lints/src/derive.rs
+++ b/src/tools/clippy/clippy_lints/src/derive.rs
@@ -6,7 +6,7 @@ use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Item, ItemKind, TraitRef, UnsafeSource, Unsafety,
+    BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Item, ItemKind, TraitRef, UnsafeSource, Unsafety, LangItemRecord,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
@@ -136,7 +136,7 @@ fn check_hash_peq<'a, 'tcx>(
 ) {
     if_chain! {
         if match_path(&trait_ref.path, &paths::HASH);
-        if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
+        if let LangItemRecord::Present(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
         if let Some(def_id) = &trait_ref.trait_def_id();
         if !def_id.is_local();
         then {
diff --git a/src/tools/clippy/clippy_lints/src/doc.rs b/src/tools/clippy/clippy_lints/src/doc.rs
index 8d1e91f9adbd6..44d6768205b0f 100644
--- a/src/tools/clippy/clippy_lints/src/doc.rs
+++ b/src/tools/clippy/clippy_lints/src/doc.rs
@@ -4,6 +4,7 @@ use itertools::Itertools;
 use rustc_ast::ast::{AttrKind, Attribute};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
+use rustc_hir::LangItemRecord;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
@@ -227,7 +228,7 @@ fn lint_for_missing_headers<'a, 'tcx>(
         } else {
             if_chain! {
                 if let Some(body_id) = body_id;
-                if let Some(future) = cx.tcx.lang_items().future_trait();
+                if let LangItemRecord::Present(future) = cx.tcx.lang_items().future_trait();
                 let def_id = cx.tcx.hir().body_owner_def_id(body_id);
                 let mir = cx.tcx.optimized_mir(def_id.to_def_id());
                 let ret_ty = mir.return_ty();
diff --git a/src/tools/clippy/clippy_lints/src/eq_op.rs b/src/tools/clippy/clippy_lints/src/eq_op.rs
index d7819d737ea04..762a0fdb9b3ab 100644
--- a/src/tools/clippy/clippy_lints/src/eq_op.rs
+++ b/src/tools/clippy/clippy_lints/src/eq_op.rs
@@ -2,7 +2,7 @@ use crate::utils::{
     implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then, SpanlessEq,
 };
 use rustc_errors::Applicability;
-use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind};
+use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind, LangItemRecord};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -96,7 +96,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                     (cx.tcx.lang_items().partial_ord_trait(), true)
                 },
             };
-            if let Some(trait_id) = trait_id {
+            if let LangItemRecord::Present(trait_id) = trait_id {
                 #[allow(clippy::match_same_arms)]
                 match (&left.kind, &right.kind) {
                     // do not suggest to dereference literals
diff --git a/src/tools/clippy/clippy_lints/src/future_not_send.rs b/src/tools/clippy/clippy_lints/src/future_not_send.rs
index 17dd3cd5493e7..ae686c86f0857 100644
--- a/src/tools/clippy/clippy_lints/src/future_not_send.rs
+++ b/src/tools/clippy/clippy_lints/src/future_not_send.rs
@@ -66,7 +66,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FutureNotSend {
             let mut is_future = false;
             for p in preds.predicates {
                 if let Some(trait_ref) = p.to_opt_poly_trait_ref() {
-                    if Some(trait_ref.def_id()) == cx.tcx.lang_items().future_trait() {
+                    if cx.tcx.lang_items().future_trait().has_def_id(trait_ref.def_id()) {
                         is_future = true;
                         break;
                     }
diff --git a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
index 03ab274d9ca9c..477b9bacbd7d5 100644
--- a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
@@ -104,7 +104,7 @@ fn future_trait_ref<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &'tcx Ty<'tcx>) -> Opt
         if let ItemKind::OpaqueTy(opaque) = &item.kind;
         if opaque.bounds.len() == 1;
         if let GenericBound::Trait(poly, _) = &opaque.bounds[0];
-        if poly.trait_ref.trait_def_id() == cx.tcx.lang_items().future_trait();
+        if poly.trait_ref.trait_def_id().map_or(false, |id| cx.tcx.lang_items().future_trait().has_def_id(id));
         then {
             return Some(&poly.trait_ref);
         }
diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs
index a0947608e6077..c7191b06e1f34 100644
--- a/src/tools/clippy/clippy_lints/src/misc.rs
+++ b/src/tools/clippy/clippy_lints/src/misc.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, Mutability, PatKind, Stmt, StmtKind, Ty,
-    TyKind, UnOp,
+    TyKind, UnOp, LangItemRecord,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -595,8 +595,8 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
 
     let other_ty = cx.tables.expr_ty_adjusted(other);
     let partial_eq_trait_id = match cx.tcx.lang_items().eq_trait() {
-        Some(id) => id,
-        None => return,
+        LangItemRecord::Present(id) => id,
+        _ => return,
     };
 
     let deref_arg_impl_partial_eq_other = arg_ty.builtin_deref(true).map_or(false, |tam| {
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index 218b0d27f7486..958b270d3623f 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -8,7 +8,7 @@ use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{BindingAnnotation, Body, FnDecl, GenericArg, HirId, ItemKind, Node, PatKind, QPath, TyKind};
+use rustc_hir::{BindingAnnotation, Body, FnDecl, GenericArg, HirId, ItemKind, Node, PatKind, QPath, TyKind, LangItemRecord};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TypeFoldable};
@@ -64,6 +64,16 @@ macro_rules! need {
     };
 }
 
+macro_rules! need_lang_item {
+    ($e: expr) => {
+        if let LangItemRecord::Present(x) = $e {
+            x
+        } else {
+            return;
+        }
+    };
+}
+
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
     #[allow(clippy::too_many_lines)]
     fn check_fn(
@@ -101,13 +111,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
         // Allow `Borrow` or functions to be taken by value
         let borrow_trait = need!(get_trait_def_id(cx, &paths::BORROW_TRAIT));
         let whitelisted_traits = [
-            need!(cx.tcx.lang_items().fn_trait()),
-            need!(cx.tcx.lang_items().fn_once_trait()),
-            need!(cx.tcx.lang_items().fn_mut_trait()),
+            need_lang_item!(cx.tcx.lang_items().fn_trait()),
+            need_lang_item!(cx.tcx.lang_items().fn_once_trait()),
+            need_lang_item!(cx.tcx.lang_items().fn_mut_trait()),
             need!(get_trait_def_id(cx, &paths::RANGE_ARGUMENT_TRAIT)),
         ];
 
-        let sized_trait = need!(cx.tcx.lang_items().sized_trait());
+        let sized_trait = need_lang_item!(cx.tcx.lang_items().sized_trait());
 
         let fn_def_id = cx.tcx.hir().local_def_id(hir_id);
 
diff --git a/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 54536ed57d3e9..782a7b1022022 100644
--- a/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -1,5 +1,5 @@
 use if_chain::if_chain;
-use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp, LangItemRecord};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -67,7 +67,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NoNegCompOpForPartialOrd {
                 };
 
                 let implements_partial_ord = {
-                    if let Some(id) = cx.tcx.lang_items().partial_ord_trait() {
+                    if let LangItemRecord::Present(id) = cx.tcx.lang_items().partial_ord_trait() {
                         utils::implements_trait(cx, ty, id, &[])
                     } else {
                         return;
diff --git a/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs b/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
index 1445df41c452f..a27a756a91c12 100644
--- a/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
+++ b/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
@@ -1,6 +1,6 @@
 use crate::utils::{is_automatically_derived, span_lint_hir};
 use if_chain::if_chain;
-use rustc_hir::{Item, ItemKind};
+use rustc_hir::{Item, ItemKind, LangItemRecord};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -35,7 +35,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PartialEqNeImpl {
         if_chain! {
             if let ItemKind::Impl{ of_trait: Some(ref trait_ref), items: impl_items, .. } = item.kind;
             if !is_automatically_derived(&*item.attrs);
-            if let Some(eq_trait) = cx.tcx.lang_items().eq_trait();
+            if let LangItemRecord::Present(eq_trait) = cx.tcx.lang_items().eq_trait();
             if trait_ref.path.res.def_id() == eq_trait;
             then {
                 for impl_item in impl_items {
diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs
index d59a2f1bae031..4f633f5f23709 100644
--- a/src/tools/clippy/clippy_lints/src/types.rs
+++ b/src/tools/clippy/clippy_lints/src/types.rs
@@ -324,7 +324,7 @@ impl Types {
                 let hir_id = hir_ty.hir_id;
                 let res = qpath_res(cx, qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
-                    if Some(def_id) == cx.tcx.lang_items().owned_box() {
+                    if cx.tcx.lang_items().owned_box().has_def_id(def_id) {
                         if let Some(span) = match_borrows_parameter(cx, qpath) {
                             span_lint_and_sugg(
                                 cx,
@@ -397,7 +397,7 @@ impl Types {
                             if let TyKind::Path(ref ty_qpath) = ty.kind;
                             let res = qpath_res(cx, ty_qpath, ty.hir_id);
                             if let Some(def_id) = res.opt_def_id();
-                            if Some(def_id) == cx.tcx.lang_items().owned_box();
+                            if cx.tcx.lang_items().owned_box().has_def_id(def_id);
                             // At this point, we know ty is Box<T>, now get T
                             if let Some(ref last) = last_path_segment(ty_qpath).args;
                             if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
@@ -513,7 +513,7 @@ impl Types {
                 let def = qpath_res(cx, qpath, hir_id);
                 if_chain! {
                     if let Some(def_id) = def.opt_def_id();
-                    if Some(def_id) == cx.tcx.lang_items().owned_box();
+                    if cx.tcx.lang_items().owned_box().has_def_id(def_id);
                     if let QPath::Resolved(None, ref path) = *qpath;
                     if let [ref bx] = *path.segments;
                     if let Some(ref params) = bx.args;