diff --git a/compiler/rustc_errors/src/decorate_diag.rs b/compiler/rustc_errors/src/decorate_diag.rs
index 5aef26ccf973d..d48b2fc4b97be 100644
--- a/compiler/rustc_errors/src/decorate_diag.rs
+++ b/compiler/rustc_errors/src/decorate_diag.rs
@@ -1,15 +1,16 @@
 /// This module provides types and traits for buffering lints until later in compilation.
 use rustc_ast::node_id::NodeId;
 use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_error_messages::MultiSpan;
 use rustc_lint_defs::{BuiltinLintDiag, Lint, LintId};
 
-use crate::{DynSend, LintDiagnostic, LintDiagnosticBox};
+use crate::{LintDiagnostic, LintDiagnosticBox};
 
 /// We can't implement `LintDiagnostic` for `BuiltinLintDiag`, because decorating some of its
 /// variants requires types we don't have yet. So, handle that case separately.
 pub enum DecorateDiagCompat {
-    Dynamic(Box<dyn for<'a> LintDiagnosticBox<'a, ()> + DynSend + 'static>),
+    Dynamic(Box<dyn for<'a> LintDiagnosticBox<'a, ()> + DynSend + DynSync + 'static>),
     Builtin(BuiltinLintDiag),
 }
 
@@ -21,7 +22,9 @@ impl std::fmt::Debug for DecorateDiagCompat {
 
 impl !LintDiagnostic<'_, ()> for BuiltinLintDiag {}
 
-impl<D: for<'a> LintDiagnostic<'a, ()> + DynSend + 'static> From<D> for DecorateDiagCompat {
+impl<D: for<'a> LintDiagnostic<'a, ()> + DynSend + DynSync + 'static> From<D>
+    for DecorateDiagCompat
+{
     #[inline]
     fn from(d: D) -> Self {
         Self::Dynamic(Box::new(d))
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 940cc30c17e6e..1e010dbcea9b4 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -1,430 +1,83 @@
-use std::ffi::OsStr;
+//! To improve compile times and code size for the compiler itself, query
+//! values are "erased" in some contexts (e.g. inside in-memory cache types),
+//! to reduce the number of generic instantiations created during codegen.
+
 use std::intrinsics::transmute_unchecked;
 use std::mem::MaybeUninit;
 
-use rustc_ast::tokenstream::TokenStream;
-use rustc_span::ErrorGuaranteed;
-use rustc_span::source_map::Spanned;
-
-use crate::mir::interpret::EvalToValTreeResult;
-use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
-use crate::query::CyclePlaceholder;
-use crate::traits::solve;
-use crate::ty::adjustment::CoerceUnsizedInfo;
-use crate::ty::{self, Ty, TyCtxt};
-use crate::{mir, traits};
-
+/// Internal implementation detail of [`Erased`].
 #[derive(Copy, Clone)]
-pub struct Erased<T: Copy> {
-    // We use `MaybeUninit` here so we can store any value
-    // in `data` since we aren't actually storing a `T`.
-    data: MaybeUninit<T>,
-}
-
-pub trait EraseType: Copy {
-    type Result: Copy;
-}
-
-// Allow `type_alias_bounds` since compilation will fail without `EraseType`.
-#[allow(type_alias_bounds)]
-pub type Erase<T: EraseType> = Erased<impl Copy>;
-
+pub struct ErasedData<Storage: Copy> {
+    /// We use `MaybeUninit` here to make sure it's legal to store a transmuted
+    /// value that isn't actually of type `Storage`.
+    data: MaybeUninit<Storage>,
+}
+
+/// Trait for types that can be erased into [`Erased<Self>`].
+///
+/// Erasing and unerasing values is performed by [`erase_val`] and [`restore_val`].
+pub trait Erasable: Copy {
+    /// Storage type to used for erased values of this type.
+    /// Should be `[u8; N]`, where N is equal to `size_of::<Self>`.
+    ///
+    /// [`ErasedData`] wraps this storage type in `MaybeUninit` to ensure that
+    /// transmutes to/from erased storage are well-defined.
+    type Storage: Copy;
+}
+
+/// A value of `T` that has been "erased" into some opaque storage type.
+///
+/// This is helpful for reducing the number of concrete instantiations needed
+/// during codegen when building the compiler.
+///
+/// Using an opaque type alias allows the type checker to enforce that
+/// `Erased<T>` and `Erased<U>` are still distinct types, while allowing
+/// monomorphization to see that they might actually use the same storage type.
+pub type Erased<T: Erasable> = ErasedData<impl Copy>;
+
+/// Erases a value of type `T` into `Erased<T>`.
+///
+/// `Erased<T>` and `Erased<U>` are type-checked as distinct types, but codegen
+/// can see whether they actually have the same storage type.
 #[inline(always)]
-#[define_opaque(Erase)]
-pub fn erase<T: EraseType>(src: T) -> Erase<T> {
+#[define_opaque(Erased)]
+pub fn erase_val<T: Erasable>(value: T) -> Erased<T> {
     // Ensure the sizes match
     const {
-        if size_of::<T>() != size_of::<T::Result>() {
-            panic!("size of T must match erased type T::Result")
+        if size_of::<T>() != size_of::<T::Storage>() {
+            panic!("size of T must match erased type <T as Erasable>::Storage")
         }
     };
 
-    Erased::<<T as EraseType>::Result> {
+    ErasedData::<<T as Erasable>::Storage> {
         // `transmute_unchecked` is needed here because it does not have `transmute`'s size check
-        // (and thus allows to transmute between `T` and `MaybeUninit<T::Result>`) (we do the size
+        // (and thus allows to transmute between `T` and `MaybeUninit<T::Storage>`) (we do the size
         // check ourselves in the `const` block above).
         //
         // `transmute_copy` is also commonly used for this (and it would work here since
-        // `EraseType: Copy`), but `transmute_unchecked` better explains the intent.
+        // `Erasable: Copy`), but `transmute_unchecked` better explains the intent.
         //
         // SAFETY: It is safe to transmute to MaybeUninit for types with the same sizes.
-        data: unsafe { transmute_unchecked::<T, MaybeUninit<T::Result>>(src) },
+        data: unsafe { transmute_unchecked::<T, MaybeUninit<T::Storage>>(value) },
     }
 }
 
-/// Restores an erased value.
+/// Restores an erased value to its real type.
+///
+/// This relies on the fact that `Erased<T>` and `Erased<U>` are type-checked
+/// as distinct types, even if they use the same storage type.
 #[inline(always)]
-#[define_opaque(Erase)]
-pub fn restore<T: EraseType>(value: Erase<T>) -> T {
-    let value: Erased<<T as EraseType>::Result> = value;
+#[define_opaque(Erased)]
+pub fn restore_val<T: Erasable>(erased_value: Erased<T>) -> T {
+    let ErasedData { data }: ErasedData<<T as Erasable>::Storage> = erased_value;
     // See comment in `erase` for why we use `transmute_unchecked`.
     //
     // SAFETY: Due to the use of impl Trait in `Erase` the only way to safely create an instance
     // of `Erase` is to call `erase`, so we know that `value.data` is a valid instance of `T` of
     // the right size.
-    unsafe { transmute_unchecked::<MaybeUninit<T::Result>, T>(value.data) }
-}
-
-impl<T> EraseType for &'_ T {
-    type Result = [u8; size_of::<&'static ()>()];
-}
-
-impl<T> EraseType for &'_ [T] {
-    type Result = [u8; size_of::<&'static [()]>()];
-}
-
-impl EraseType for &'_ OsStr {
-    type Result = [u8; size_of::<&'static OsStr>()];
-}
-
-impl<T> EraseType for &'_ ty::List<T> {
-    type Result = [u8; size_of::<&'static ty::List<()>>()];
-}
-
-impl<T> EraseType for &'_ ty::ListWithCachedTypeInfo<T> {
-    type Result = [u8; size_of::<&'static ty::ListWithCachedTypeInfo<()>>()];
-}
-
-impl<I: rustc_index::Idx, T> EraseType for &'_ rustc_index::IndexSlice<I, T> {
-    type Result = [u8; size_of::<&'static rustc_index::IndexSlice<u32, ()>>()];
-}
-
-impl<T> EraseType for Result<&'_ T, traits::query::NoSolution> {
-    type Result = [u8; size_of::<Result<&'static (), traits::query::NoSolution>>()];
-}
-
-impl<T> EraseType for Result<&'_ [T], traits::query::NoSolution> {
-    type Result = [u8; size_of::<Result<&'static [()], traits::query::NoSolution>>()];
-}
-
-impl<T> EraseType for Result<&'_ T, rustc_errors::ErrorGuaranteed> {
-    type Result = [u8; size_of::<Result<&'static (), rustc_errors::ErrorGuaranteed>>()];
-}
-
-impl<T> EraseType for Result<&'_ [T], rustc_errors::ErrorGuaranteed> {
-    type Result = [u8; size_of::<Result<&'static [()], rustc_errors::ErrorGuaranteed>>()];
-}
-
-impl<T> EraseType for Result<&'_ T, traits::CodegenObligationError> {
-    type Result = [u8; size_of::<Result<&'static (), traits::CodegenObligationError>>()];
-}
-
-impl<T> EraseType for Result<&'_ T, &'_ ty::layout::FnAbiError<'_>> {
-    type Result = [u8; size_of::<Result<&'static (), &'static ty::layout::FnAbiError<'static>>>()];
-}
-
-impl<T> EraseType for Result<(&'_ T, crate::thir::ExprId), rustc_errors::ErrorGuaranteed> {
-    type Result = [u8; size_of::<
-        Result<(&'static (), crate::thir::ExprId), rustc_errors::ErrorGuaranteed>,
-    >()];
-}
-
-impl EraseType for Result<Option<ty::Instance<'_>>, rustc_errors::ErrorGuaranteed> {
-    type Result =
-        [u8; size_of::<Result<Option<ty::Instance<'static>>, rustc_errors::ErrorGuaranteed>>()];
-}
-
-impl EraseType for Result<CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed> {
-    type Result = [u8; size_of::<Result<CoerceUnsizedInfo, rustc_errors::ErrorGuaranteed>>()];
-}
-
-impl EraseType
-    for Result<Option<ty::EarlyBinder<'_, ty::Const<'_>>>, rustc_errors::ErrorGuaranteed>
-{
-    type Result = [u8; size_of::<
-        Result<Option<ty::EarlyBinder<'static, ty::Const<'static>>>, rustc_errors::ErrorGuaranteed>,
-    >()];
-}
-
-impl EraseType for Result<ty::GenericArg<'_>, traits::query::NoSolution> {
-    type Result = [u8; size_of::<Result<ty::GenericArg<'static>, traits::query::NoSolution>>()];
-}
-
-impl EraseType for Result<bool, &ty::layout::LayoutError<'_>> {
-    type Result = [u8; size_of::<Result<bool, &'static ty::layout::LayoutError<'static>>>()];
-}
-
-impl EraseType for Result<rustc_abi::TyAndLayout<'_, Ty<'_>>, &ty::layout::LayoutError<'_>> {
-    type Result = [u8; size_of::<
-        Result<
-            rustc_abi::TyAndLayout<'static, Ty<'static>>,
-            &'static ty::layout::LayoutError<'static>,
-        >,
-    >()];
-}
-
-impl EraseType for Result<mir::ConstAlloc<'_>, mir::interpret::ErrorHandled> {
-    type Result = [u8; size_of::<Result<mir::ConstAlloc<'static>, mir::interpret::ErrorHandled>>()];
-}
-
-impl EraseType for Result<mir::ConstValue, mir::interpret::ErrorHandled> {
-    type Result = [u8; size_of::<Result<mir::ConstValue, mir::interpret::ErrorHandled>>()];
-}
-
-impl EraseType for Option<(mir::ConstValue, Ty<'_>)> {
-    type Result = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
-}
-
-impl EraseType for EvalToValTreeResult<'_> {
-    type Result = [u8; size_of::<EvalToValTreeResult<'static>>()];
-}
-
-impl EraseType for Result<&'_ ty::List<Ty<'_>>, ty::util::AlwaysRequiresDrop> {
-    type Result =
-        [u8; size_of::<Result<&'static ty::List<Ty<'static>>, ty::util::AlwaysRequiresDrop>>()];
-}
-
-impl EraseType for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
-    type Result = [u8; size_of::<Result<ty::EarlyBinder<'static, Ty<'_>>, CyclePlaceholder>>()];
-}
-
-impl EraseType
-    for Result<(&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]), NormalizationErrorInMono>
-{
-    type Result = [u8; size_of::<
-        Result<
-            (&'static [Spanned<MonoItem<'static>>], &'static [Spanned<MonoItem<'static>>]),
-            NormalizationErrorInMono,
-        >,
-    >()];
-}
-
-impl EraseType for Result<&'_ TokenStream, ()> {
-    type Result = [u8; size_of::<Result<&'static TokenStream, ()>>()];
-}
-
-impl<T> EraseType for Option<&'_ T> {
-    type Result = [u8; size_of::<Option<&'static ()>>()];
-}
-
-impl<T> EraseType for Option<&'_ [T]> {
-    type Result = [u8; size_of::<Option<&'static [()]>>()];
-}
-
-impl EraseType for Option<&'_ OsStr> {
-    type Result = [u8; size_of::<Option<&'static OsStr>>()];
-}
-
-impl EraseType for Option<mir::DestructuredConstant<'_>> {
-    type Result = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()];
-}
-
-impl EraseType for ty::ImplTraitHeader<'_> {
-    type Result = [u8; size_of::<ty::ImplTraitHeader<'static>>()];
-}
-
-impl EraseType for Option<ty::EarlyBinder<'_, Ty<'_>>> {
-    type Result = [u8; size_of::<Option<ty::EarlyBinder<'static, Ty<'static>>>>()];
-}
-
-impl EraseType for rustc_hir::MaybeOwner<'_> {
-    type Result = [u8; size_of::<rustc_hir::MaybeOwner<'static>>()];
-}
-
-impl<T: EraseType> EraseType for ty::EarlyBinder<'_, T> {
-    type Result = T::Result;
-}
-
-impl EraseType for ty::Binder<'_, ty::FnSig<'_>> {
-    type Result = [u8; size_of::<ty::Binder<'static, ty::FnSig<'static>>>()];
-}
-
-impl EraseType for ty::Binder<'_, ty::CoroutineWitnessTypes<TyCtxt<'_>>> {
-    type Result =
-        [u8; size_of::<ty::Binder<'static, ty::CoroutineWitnessTypes<TyCtxt<'static>>>>()];
-}
-
-impl EraseType for ty::Binder<'_, &'_ ty::List<Ty<'_>>> {
-    type Result = [u8; size_of::<ty::Binder<'static, &'static ty::List<Ty<'static>>>>()];
-}
-
-impl<T0, T1> EraseType for (&'_ T0, &'_ T1) {
-    type Result = [u8; size_of::<(&'static (), &'static ())>()];
-}
-
-impl<T0> EraseType for (solve::QueryResult<'_>, &'_ T0) {
-    type Result = [u8; size_of::<(solve::QueryResult<'static>, &'static ())>()];
-}
-
-impl<T0, T1> EraseType for (&'_ T0, &'_ [T1]) {
-    type Result = [u8; size_of::<(&'static (), &'static [()])>()];
-}
-
-impl<T0, T1> EraseType for (&'_ [T0], &'_ [T1]) {
-    type Result = [u8; size_of::<(&'static [()], &'static [()])>()];
-}
-
-impl<T0> EraseType for (&'_ T0, Result<(), ErrorGuaranteed>) {
-    type Result = [u8; size_of::<(&'static (), Result<(), ErrorGuaranteed>)>()];
-}
-
-macro_rules! trivial {
-    ($($ty:ty),+ $(,)?) => {
-        $(
-            impl EraseType for $ty {
-                type Result = [u8; size_of::<$ty>()];
-            }
-        )*
-    }
-}
-
-trivial! {
-    (),
-    bool,
-    Option<(rustc_span::def_id::DefId, rustc_session::config::EntryFnType)>,
-    Option<rustc_ast::expand::allocator::AllocatorKind>,
-    Option<rustc_hir::ConstStability>,
-    Option<rustc_hir::DefaultBodyStability>,
-    Option<rustc_hir::Stability>,
-    Option<rustc_data_structures::svh::Svh>,
-    Option<rustc_hir::def::DefKind>,
-    Option<rustc_hir::CoroutineKind>,
-    Option<rustc_hir::HirId>,
-    Option<rustc_middle::middle::stability::DeprecationEntry>,
-    Option<rustc_middle::ty::AsyncDestructor>,
-    Option<rustc_middle::ty::Destructor>,
-    Option<rustc_middle::ty::ImplTraitInTraitData>,
-    Option<rustc_middle::ty::ScalarInt>,
-    Option<rustc_span::def_id::CrateNum>,
-    Option<rustc_span::def_id::DefId>,
-    Option<rustc_span::def_id::LocalDefId>,
-    Option<rustc_span::Span>,
-    Option<rustc_abi::FieldIdx>,
-    Option<rustc_target::spec::PanicStrategy>,
-    Option<usize>,
-    Option<rustc_middle::ty::IntrinsicDef>,
-    Option<rustc_abi::Align>,
-    Result<(), rustc_errors::ErrorGuaranteed>,
-    Result<(), rustc_middle::traits::query::NoSolution>,
-    Result<rustc_middle::traits::EvaluationResult, rustc_middle::traits::OverflowError>,
-    rustc_abi::ReprOptions,
-    rustc_ast::expand::allocator::AllocatorKind,
-    rustc_hir::DefaultBodyStability,
-    rustc_hir::attrs::Deprecation,
-    rustc_hir::attrs::EiiDecl,
-    rustc_hir::attrs::EiiImpl,
-    rustc_data_structures::svh::Svh,
-    rustc_errors::ErrorGuaranteed,
-    rustc_hir::Constness,
-    rustc_hir::ConstStability,
-    rustc_hir::def_id::DefId,
-    rustc_hir::def_id::DefIndex,
-    rustc_hir::def_id::LocalDefId,
-    rustc_hir::def_id::LocalModDefId,
-    rustc_hir::def::DefKind,
-    rustc_hir::Defaultness,
-    rustc_hir::definitions::DefKey,
-    rustc_hir::CoroutineKind,
-    rustc_hir::HirId,
-    rustc_hir::IsAsync,
-    rustc_hir::ItemLocalId,
-    rustc_hir::LangItem,
-    rustc_hir::OpaqueTyOrigin<rustc_hir::def_id::DefId>,
-    rustc_hir::OwnerId,
-    rustc_hir::Stability,
-    rustc_hir::Upvar,
-    rustc_index::bit_set::FiniteBitSet<u32>,
-    rustc_middle::middle::deduced_param_attrs::DeducedParamAttrs,
-    rustc_middle::middle::dependency_format::Linkage,
-    rustc_middle::middle::exported_symbols::SymbolExportInfo,
-    rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
-    rustc_middle::middle::resolve_bound_vars::ResolvedArg,
-    rustc_middle::middle::stability::DeprecationEntry,
-    rustc_middle::mir::ConstQualifs,
-    rustc_middle::mir::ConstValue,
-    rustc_middle::mir::interpret::AllocId,
-    rustc_middle::mir::interpret::CtfeProvenance,
-    rustc_middle::mir::interpret::ErrorHandled,
-    rustc_middle::thir::ExprId,
-    rustc_middle::traits::CodegenObligationError,
-    rustc_middle::traits::EvaluationResult,
-    rustc_middle::traits::OverflowError,
-    rustc_middle::traits::query::NoSolution,
-    rustc_middle::traits::WellFormedLoc,
-    rustc_middle::ty::adjustment::CoerceUnsizedInfo,
-    rustc_middle::ty::AssocItem,
-    rustc_middle::ty::AssocContainer,
-    rustc_middle::ty::Asyncness,
-    rustc_middle::ty::AsyncDestructor,
-    rustc_middle::ty::BoundVariableKind,
-    rustc_middle::ty::AnonConstKind,
-    rustc_middle::ty::Destructor,
-    rustc_middle::ty::fast_reject::SimplifiedType,
-    rustc_middle::ty::ImplPolarity,
-    rustc_middle::ty::Representability,
-    rustc_middle::ty::UnusedGenericParams,
-    rustc_middle::ty::util::AlwaysRequiresDrop,
-    rustc_middle::ty::Visibility<rustc_span::def_id::DefId>,
-    rustc_middle::middle::codegen_fn_attrs::SanitizerFnAttrs,
-    rustc_session::config::CrateType,
-    rustc_session::config::EntryFnType,
-    rustc_session::config::OptLevel,
-    rustc_session::config::SymbolManglingVersion,
-    rustc_session::cstore::CrateDepKind,
-    rustc_session::cstore::ExternCrate,
-    rustc_session::cstore::LinkagePreference,
-    rustc_session::Limits,
-    rustc_session::lint::LintExpectationId,
-    rustc_span::def_id::CrateNum,
-    rustc_span::def_id::DefPathHash,
-    rustc_span::ExpnHash,
-    rustc_span::ExpnId,
-    rustc_span::Span,
-    rustc_span::Symbol,
-    rustc_span::Ident,
-    rustc_target::spec::PanicStrategy,
-    rustc_type_ir::Variance,
-    u32,
-    usize,
-}
-
-macro_rules! tcx_lifetime {
-    ($($($fake_path:ident)::+),+ $(,)?) => {
-        $(
-            impl<'tcx> EraseType for $($fake_path)::+<'tcx> {
-                type Result = [u8; size_of::<$($fake_path)::+<'static>>()];
-            }
-        )*
-    }
+    unsafe { transmute_unchecked::<MaybeUninit<T::Storage>, T>(data) }
 }
 
-tcx_lifetime! {
-    rustc_middle::middle::exported_symbols::ExportedSymbol,
-    rustc_middle::mir::Const,
-    rustc_middle::mir::DestructuredConstant,
-    rustc_middle::mir::ConstAlloc,
-    rustc_middle::mir::interpret::GlobalId,
-    rustc_middle::mir::interpret::LitToConstInput,
-    rustc_middle::mir::interpret::EvalStaticInitializerRawResult,
-    rustc_middle::mir::mono::MonoItemPartitions,
-    rustc_middle::traits::query::MethodAutoderefStepsResult,
-    rustc_middle::traits::query::type_op::AscribeUserType,
-    rustc_middle::traits::query::type_op::Eq,
-    rustc_middle::traits::query::type_op::ProvePredicate,
-    rustc_middle::traits::query::type_op::Subtype,
-    rustc_middle::ty::AdtDef,
-    rustc_middle::ty::AliasTy,
-    rustc_middle::ty::ClauseKind,
-    rustc_middle::ty::ClosureTypeInfo,
-    rustc_middle::ty::Const,
-    rustc_middle::ty::DestructuredAdtConst,
-    rustc_middle::ty::ExistentialTraitRef,
-    rustc_middle::ty::FnSig,
-    rustc_middle::ty::GenericArg,
-    rustc_middle::ty::GenericPredicates,
-    rustc_middle::ty::ConstConditions,
-    rustc_middle::ty::inhabitedness::InhabitedPredicate,
-    rustc_middle::ty::Instance,
-    rustc_middle::ty::InstanceKind,
-    rustc_middle::ty::layout::FnAbiError,
-    rustc_middle::ty::layout::LayoutError,
-    rustc_middle::ty::ParamEnv,
-    rustc_middle::ty::TypingEnv,
-    rustc_middle::ty::Predicate,
-    rustc_middle::ty::SymbolName,
-    rustc_middle::ty::TraitRef,
-    rustc_middle::ty::Ty,
-    rustc_middle::ty::UnevaluatedConst,
-    rustc_middle::ty::ValTree,
-    rustc_middle::ty::VtblEntry,
+impl<T: Copy> Erasable for T {
+    type Storage = T;
 }
diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs
index ee828ae55f7a3..e41d23f82f127 100644
--- a/compiler/rustc_middle/src/query/inner.rs
+++ b/compiler/rustc_middle/src/query/inner.rs
@@ -11,7 +11,7 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
 use crate::dep_graph;
 use crate::query::IntoQueryParam;
-use crate::query::erase::{self, Erase, EraseType};
+use crate::query::erase::{self, Erasable, Erased};
 use crate::ty::TyCtxt;
 
 /// Shared implementation of `tcx.$query(..)` and `tcx.at(span).$query(..)`
@@ -63,15 +63,15 @@ pub(crate) fn query_ensure_error_guaranteed<'tcx, Cache, T>(
     check_cache: bool,
 ) -> Result<(), ErrorGuaranteed>
 where
-    Cache: QueryCache<Value = Erase<Result<T, ErrorGuaranteed>>>,
-    Result<T, ErrorGuaranteed>: EraseType,
+    Cache: QueryCache<Value = Erased<Result<T, ErrorGuaranteed>>>,
+    Result<T, ErrorGuaranteed>: Erasable,
 {
     let key = key.into_query_param();
     if let Some(res) = try_get_cached(tcx, query_cache, &key) {
-        erase::restore(res).map(drop)
+        erase::restore_val(res).map(drop)
     } else {
         execute_query(tcx, DUMMY_SP, key, QueryMode::Ensure { check_cache })
-            .map(erase::restore)
+            .map(erase::restore_val)
             .map(|res| res.map(drop))
             // Either we actually executed the query, which means we got a full `Result`,
             // or we can just assume the query succeeded, because it was green in the
@@ -90,17 +90,17 @@ pub(crate) fn query_feed<'tcx, Cache, Value>(
     hasher: Option<fn(&mut StableHashingContext<'_>, &Value) -> Fingerprint>,
     cache: &Cache,
     key: Cache::Key,
-    erased: Erase<Value>,
+    erased: Erased<Value>,
 ) where
-    Cache: QueryCache<Value = Erase<Value>>,
+    Cache: QueryCache<Value = Erased<Value>>,
     Cache::Key: DepNodeParams<TyCtxt<'tcx>>,
-    Value: EraseType + Debug,
+    Value: Erasable + Debug,
 {
-    let value = erase::restore::<Value>(erased);
+    let value = erase::restore_val::<Value>(erased);
 
     match try_get_cached(tcx, cache, &key) {
         Some(old) => {
-            let old = erase::restore::<Value>(old);
+            let old = erase::restore_val::<Value>(old);
             if let Some(hasher) = hasher {
                 let (value_hash, old_hash): (Fingerprint, Fingerprint) = tcx
                     .with_stable_hashing_context(|mut hcx| {
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 2f83f3078e89f..c90f072302a5b 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -121,7 +121,6 @@ use crate::mir::interpret::{
 use crate::mir::mono::{
     CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions, NormalizationErrorInMono,
 };
-use crate::query::erase::{Erase, erase, restore};
 use crate::query::plumbing::{CyclePlaceholder, DynamicQuery};
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 17330f4e14bee..8dfc4aad1bad5 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -263,6 +263,7 @@ macro_rules! define_callbacks {
         pub mod queries {
             $(pub mod $name {
                 use super::super::*;
+                use $crate::query::erase::{self, Erased};
 
                 pub type Key<'tcx> = $($K)*;
                 pub type Value<'tcx> = $V;
@@ -285,29 +286,33 @@ macro_rules! define_callbacks {
                 #[inline(always)]
                 pub fn provided_to_erased<'tcx>(
                     _tcx: TyCtxt<'tcx>,
-                    value: ProvidedValue<'tcx>,
-                ) -> Erase<Value<'tcx>> {
-                    erase(query_if_arena!([$($modifiers)*]
+                    provided_value: ProvidedValue<'tcx>,
+                ) -> Erased<Value<'tcx>> {
+                    // Store the provided value in an arena and get a reference
+                    // to it, for queries with `arena_cache`.
+                    let value: Value<'tcx> = query_if_arena!([$($modifiers)*]
                         {
                             use $crate::query::arena_cached::ArenaCached;
 
                             if mem::needs_drop::<<$V as ArenaCached<'tcx>>::Allocated>() {
                                 <$V as ArenaCached>::alloc_in_arena(
                                     |v| _tcx.query_system.arenas.$name.alloc(v),
-                                    value,
+                                    provided_value,
                                 )
                             } else {
                                 <$V as ArenaCached>::alloc_in_arena(
                                     |v| _tcx.arena.dropless.alloc(v),
-                                    value,
+                                    provided_value,
                                 )
                             }
                         }
-                        (value)
-                    ))
+                        // Otherwise, the provided value is the value.
+                        (provided_value)
+                    );
+                    erase::erase_val(value)
                 }
 
-                pub type Storage<'tcx> = <$($K)* as keys::Key>::Cache<Erase<$V>>;
+                pub type Storage<'tcx> = <$($K)* as keys::Key>::Cache<Erased<$V>>;
 
                 // Ensure that keys grow no larger than 88 bytes by accident.
                 // Increase this limit if necessary, but do try to keep the size low if possible
@@ -408,7 +413,9 @@ macro_rules! define_callbacks {
             #[inline(always)]
             pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V
             {
-                restore::<$V>(crate::query::inner::query_get_at(
+                use $crate::query::{erase, inner};
+
+                erase::restore_val::<$V>(inner::query_get_at(
                     self.tcx,
                     self.tcx.query_system.fns.engine.$name,
                     &self.tcx.query_system.caches.$name,
@@ -474,7 +481,7 @@ macro_rules! define_callbacks {
                 Span,
                 queries::$name::Key<'tcx>,
                 QueryMode,
-            ) -> Option<Erase<$V>>,)*
+            ) -> Option<$crate::query::erase::Erased<$V>>,)*
         }
     };
 }
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 57027e937a4a9..c679825e4aec8 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -10,7 +10,6 @@ use rustc_data_structures::stable_hasher::HashStable;
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::arena::Arena;
 use rustc_middle::dep_graph::{self, DepKind, DepKindVTable, DepNodeIndex};
-use rustc_middle::query::erase::{Erase, erase, restore};
 use rustc_middle::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache};
 use rustc_middle::query::plumbing::{DynamicQuery, QuerySystem, QuerySystemFns};
 use rustc_middle::query::{
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 246152f5390c6..916f38d08cbd3 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -267,7 +267,10 @@ macro_rules! feedable {
 
 macro_rules! hash_result {
     ([][$V:ty]) => {{
-        Some(|hcx, result| dep_graph::hash_result(hcx, &restore::<$V>(*result)))
+        Some(|hcx, result| {
+            let result = &::rustc_middle::query::erase::restore_val::<$V>(*result);
+            ::rustc_query_system::dep_graph::hash_result(hcx, result)
+        })
     }};
     ([(no_hash) $($rest:tt)*][$V:ty]) => {{
         None
@@ -570,6 +573,7 @@ macro_rules! define_queries {
         pub(crate) mod query_impl { $(pub(crate) mod $name {
             use super::super::*;
             use std::marker::PhantomData;
+            use ::rustc_middle::query::erase::{self, Erased};
 
             pub(crate) mod get_query_incr {
                 use super::*;
@@ -582,7 +586,7 @@ macro_rules! define_queries {
                     span: Span,
                     key: queries::$name::Key<'tcx>,
                     mode: QueryMode,
-                ) -> Option<Erase<queries::$name::Value<'tcx>>> {
+                ) -> Option<Erased<queries::$name::Value<'tcx>>> {
                     #[cfg(debug_assertions)]
                     let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
                     get_query_incr(
@@ -604,7 +608,7 @@ macro_rules! define_queries {
                     span: Span,
                     key: queries::$name::Key<'tcx>,
                     __mode: QueryMode,
-                ) -> Option<Erase<queries::$name::Value<'tcx>>> {
+                ) -> Option<Erased<queries::$name::Value<'tcx>>> {
                     Some(get_query_non_incr(
                         QueryType::config(tcx),
                         QueryCtxt::new(tcx),
@@ -625,7 +629,7 @@ macro_rules! define_queries {
                     query_state: std::mem::offset_of!(QueryStates<'tcx>, $name),
                     query_cache: std::mem::offset_of!(QueryCaches<'tcx>, $name),
                     cache_on_disk: |tcx, key| ::rustc_middle::query::cached::$name(tcx, key),
-                    execute_query: |tcx, key| erase(tcx.$name(key)),
+                    execute_query: |tcx, key| erase::erase_val(tcx.$name(key)),
                     compute: |tcx, key| {
                         #[cfg(debug_assertions)]
                         let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
@@ -663,7 +667,7 @@ macro_rules! define_queries {
                     }),
                     value_from_cycle_error: |tcx, cycle, guar| {
                         let result: queries::$name::Value<'tcx> = Value::from_cycle_error(tcx, cycle, guar);
-                        erase(result)
+                        erase::erase_val(result)
                     },
                     loadable_from_disk: |_tcx, _key, _index| {
                         should_ever_cache_on_disk!([$($modifiers)*] {
@@ -674,7 +678,7 @@ macro_rules! define_queries {
                         })
                     },
                     hash_result: hash_result!([$($modifiers)*][queries::$name::Value<'tcx>]),
-                    format_value: |value| format!("{:?}", restore::<queries::$name::Value<'tcx>>(*value)),
+                    format_value: |value| format!("{:?}", erase::restore_val::<queries::$name::Value<'tcx>>(*value)),
                 }
             }
 
@@ -704,7 +708,7 @@ macro_rules! define_queries {
 
                 #[inline(always)]
                 fn restore(value: <Self::Config as QueryConfig<QueryCtxt<'tcx>>>::Value) -> Self::RestoredValue {
-                    restore::<queries::$name::Value<'tcx>>(value)
+                    erase::restore_val::<queries::$name::Value<'tcx>>(value)
                 }
             }