diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs
index 0f408375e05f3..3cd148cd44278 100644
--- a/compiler/rustc_middle/src/infer/canonical.rs
+++ b/compiler/rustc_middle/src/infer/canonical.rs
@@ -142,10 +142,6 @@ impl<'tcx, R> QueryResponse<'tcx, R> {
pub type QueryOutlivesConstraint<'tcx> =
(ty::OutlivesPredicate<'tcx, GenericArg<'tcx>>, ConstraintCategory<'tcx>);
-TrivialTypeTraversalImpls! {
- crate::infer::canonical::Certainty,
-}
-
#[derive(Default)]
pub struct CanonicalParamEnvCache<'tcx> {
map: Lock<
diff --git a/compiler/rustc_middle/src/mir/basic_blocks.rs b/compiler/rustc_middle/src/mir/basic_blocks.rs
index 3eb563d7d6e57..c32cf5f825334 100644
--- a/compiler/rustc_middle/src/mir/basic_blocks.rs
+++ b/compiler/rustc_middle/src/mir/basic_blocks.rs
@@ -163,6 +163,7 @@ impl<'tcx> graph::Predecessors for BasicBlocks<'tcx> {
}
}
+// Done here instead of in `structural_impls.rs` because `Cache` is private, as is `basic_blocks`.
TrivialTypeTraversalImpls! { Cache }
impl<S: Encoder> Encodable<S> for Cache {
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 8c085fa310ab5..1222ba052cceb 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -95,8 +95,6 @@ impl From<ReportedErrorInfo> for ErrorGuaranteed {
}
}
-TrivialTypeTraversalImpls! { ErrorHandled }
-
pub type EvalToAllocationRawResult<'tcx> = Result<ConstAlloc<'tcx>, ErrorHandled>;
pub type EvalStaticInitializerRawResult<'tcx> = Result<ConstAllocation<'tcx>, ErrorHandled>;
pub type EvalToConstValueResult<'tcx> = Result<ConstValue<'tcx>, ErrorHandled>;
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index cfb78e5dddff6..68d5e5f4dd291 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -34,7 +34,6 @@ use self::visit::TyContext;
use crate::mir::interpret::{AllocRange, Scalar};
use crate::mir::visit::MirVisitable;
use crate::ty::codec::{TyDecoder, TyEncoder};
-use crate::ty::fold::{FallibleTypeFolder, TypeFoldable};
use crate::ty::print::{FmtPrinter, Printer, pretty_print_const, with_no_trimmed_paths};
use crate::ty::visit::TypeVisitableExt;
use crate::ty::{
@@ -59,7 +58,6 @@ pub mod tcx;
mod terminator;
pub mod traversal;
-mod type_foldable;
pub mod visit;
pub use consts::*;
@@ -927,8 +925,6 @@ pub enum BindingForm<'tcx> {
RefForGuard,
}
-TrivialTypeTraversalImpls! { BindingForm<'tcx> }
-
mod binding_form_impl {
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_query_system::ich::StableHashingContext;
diff --git a/compiler/rustc_middle/src/mir/type_foldable.rs b/compiler/rustc_middle/src/mir/type_foldable.rs
deleted file mode 100644
index 9893dd0484cbe..0000000000000
--- a/compiler/rustc_middle/src/mir/type_foldable.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! `TypeFoldable` implementations for MIR types
-
-use rustc_ast::InlineAsmTemplatePiece;
-use rustc_hir::UnsafeBinderCastKind;
-use rustc_hir::def_id::LocalDefId;
-
-use super::*;
-
-TrivialTypeTraversalImpls! {
- BlockTailInfo,
- MirPhase,
- SourceInfo,
- FakeReadCause,
- RetagKind,
- SourceScope,
- SourceScopeLocalData,
- UserTypeAnnotationIndex,
- BorrowKind,
- RawPtrKind,
- CastKind,
- BasicBlock,
- SwitchTargets,
- CoroutineKind,
- CoroutineSavedLocal,
- UnsafeBinderCastKind,
-}
-
-TrivialTypeTraversalImpls! {
- ConstValue<'tcx>,
- NullOp<'tcx>,
-}
-
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [InlineAsmTemplatePiece] {
- fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
- self,
- _folder: &mut F,
- ) -> Result<Self, F::Error> {
- Ok(self)
- }
-}
-
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [Span] {
- fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
- self,
- _folder: &mut F,
- ) -> Result<Self, F::Error> {
- Ok(self)
- }
-}
-
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<LocalDefId> {
- fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
- self,
- _folder: &mut F,
- ) -> Result<Self, F::Error> {
- Ok(self)
- }
-}
-
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<PlaceElem<'tcx>> {
- fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
- self,
- folder: &mut F,
- ) -> Result<Self, F::Error> {
- ty::util::fold_list(self, folder, |tcx, v| tcx.mk_place_elems(v))
- }
-}
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index d0ce4e6242ea6..1314a2356103b 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -427,10 +427,6 @@ pub enum IsConstable {
Ctor,
}
-TrivialTypeTraversalAndLiftImpls! {
- IsConstable,
-}
-
/// The 'location' at which we try to perform HIR-based wf checking.
/// This information is used to obtain an `hir::Ty`, which
/// we can walk in order to obtain precise spans for any
diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs
index 094fc62afbbf1..b7cd545d02db4 100644
--- a/compiler/rustc_middle/src/traits/select.rs
+++ b/compiler/rustc_middle/src/traits/select.rs
@@ -260,8 +260,6 @@ impl From<ErrorGuaranteed> for OverflowError {
}
}
-TrivialTypeTraversalImpls! { OverflowError }
-
impl<'tcx> From<OverflowError> for SelectionError<'tcx> {
fn from(overflow_error: OverflowError) -> SelectionError<'tcx> {
match overflow_error {
diff --git a/compiler/rustc_middle/src/ty/abstract_const.rs b/compiler/rustc_middle/src/ty/abstract_const.rs
index 002d381962124..c9b9ec771b324 100644
--- a/compiler/rustc_middle/src/ty/abstract_const.rs
+++ b/compiler/rustc_middle/src/ty/abstract_const.rs
@@ -30,8 +30,6 @@ impl From<ErrorGuaranteed> for NotConstEvaluatable {
}
}
-TrivialTypeTraversalImpls! { NotConstEvaluatable }
-
pub type BoundAbstractConst<'tcx> =
Result<Option<EarlyBinder<'tcx, ty::Const<'tcx>>>, ErrorGuaranteed>;
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 86248b495cdc3..1a98db54581bc 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -76,11 +76,11 @@ use crate::traits::solve::{
};
use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
use crate::ty::{
- self, AdtDef, AdtDefData, AdtKind, Binder, BoundConstness, Clause, Clauses, Const, GenericArg,
- GenericArgs, GenericArgsRef, GenericParamDefKind, ImplPolarity, List, ListWithCachedTypeInfo,
- ParamConst, ParamTy, Pattern, PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate,
- PredicateKind, PredicatePolarity, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty,
- TyKind, TyVid, Visibility,
+ self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, GenericArg, GenericArgs,
+ GenericArgsRef, GenericParamDefKind, List, ListWithCachedTypeInfo, ParamConst, ParamTy,
+ Pattern, PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind,
+ PredicatePolarity, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid,
+ Visibility,
};
#[allow(rustc::usage_of_ty_tykind)]
@@ -2243,21 +2243,23 @@ macro_rules! nop_list_lift {
};
}
-nop_lift! {type_; Ty<'a> => Ty<'tcx>}
-nop_lift! {region; Region<'a> => Region<'tcx>}
-nop_lift! {const_; Const<'a> => Const<'tcx>}
-nop_lift! {pat; Pattern<'a> => Pattern<'tcx>}
-nop_lift! {const_allocation; ConstAllocation<'a> => ConstAllocation<'tcx>}
-nop_lift! {predicate; Predicate<'a> => Predicate<'tcx>}
-nop_lift! {predicate; Clause<'a> => Clause<'tcx>}
-nop_lift! {layout; Layout<'a> => Layout<'tcx>}
-
-nop_list_lift! {type_lists; Ty<'a> => Ty<'tcx>}
-nop_list_lift! {poly_existential_predicates; PolyExistentialPredicate<'a> => PolyExistentialPredicate<'tcx>}
-nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariableKind}
+nop_lift! { type_; Ty<'a> => Ty<'tcx> }
+nop_lift! { region; Region<'a> => Region<'tcx> }
+nop_lift! { const_; Const<'a> => Const<'tcx> }
+nop_lift! { pat; Pattern<'a> => Pattern<'tcx> }
+nop_lift! { const_allocation; ConstAllocation<'a> => ConstAllocation<'tcx> }
+nop_lift! { predicate; Predicate<'a> => Predicate<'tcx> }
+nop_lift! { predicate; Clause<'a> => Clause<'tcx> }
+nop_lift! { layout; Layout<'a> => Layout<'tcx> }
+
+nop_list_lift! { type_lists; Ty<'a> => Ty<'tcx> }
+nop_list_lift! {
+ poly_existential_predicates; PolyExistentialPredicate<'a> => PolyExistentialPredicate<'tcx>
+}
+nop_list_lift! { bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariableKind }
// This is the impl for `&'a GenericArgs<'a>`.
-nop_list_lift! {args; GenericArg<'a> => GenericArg<'tcx>}
+nop_list_lift! { args; GenericArg<'a> => GenericArg<'tcx> }
macro_rules! nop_slice_lift {
($ty:ty => $lifted:ty) => {
@@ -2277,11 +2279,7 @@ macro_rules! nop_slice_lift {
};
}
-nop_slice_lift! {ty::ValTree<'a> => ty::ValTree<'tcx>}
-
-TrivialLiftImpls! {
- ImplPolarity, PredicatePolarity, Promoted, BoundConstness,
-}
+nop_slice_lift! { ty::ValTree<'a> => ty::ValTree<'tcx> }
macro_rules! sty_debug_print {
($fmt: expr, $ctxt: expr, $($variant: ident),*) => {{
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 03b26b4453800..c33f952fc8640 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -6,15 +6,18 @@
use std::fmt::{self, Debug};
use rustc_abi::TyAndLayout;
+use rustc_ast::InlineAsmTemplatePiece;
use rustc_ast_ir::try_visit;
use rustc_ast_ir::visit::VisitorResult;
use rustc_hir::def::Namespace;
+use rustc_hir::def_id::LocalDefId;
+use rustc_span::Span;
use rustc_span::source_map::Spanned;
use rustc_type_ir::ConstKind;
use super::print::PrettyPrinter;
use super::{GenericArg, GenericArgKind, Pattern, Region};
-use crate::mir::interpret;
+use crate::mir::PlaceElem;
use crate::ty::fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable};
use crate::ty::print::{FmtPrinter, Printer, with_no_trimmed_paths};
use crate::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
@@ -221,76 +224,89 @@ impl<'tcx> fmt::Debug for Region<'tcx> {
// copy...), just add them to one of these lists as appropriate.
// For things for which the type library provides traversal implementations
-// for all Interners, we only need to provide a Lift implementation:
+// for all Interners, we only need to provide a Lift implementation.
TrivialLiftImpls! {
- (),
- bool,
- usize,
- u64,
+ (),
+ bool,
+ usize,
+ u64,
+ // tidy-alphabetical-start
+ crate::mir::interpret::AllocId,
+ crate::mir::interpret::Scalar,
+ crate::mir::Promoted,
+ rustc_abi::ExternAbi,
+ rustc_abi::Size,
+ rustc_hir::Safety,
+ rustc_type_ir::BoundConstness,
+ rustc_type_ir::PredicatePolarity,
+ // tidy-alphabetical-end
}
// For some things about which the type library does not know, or does not
// provide any traversal implementations, we need to provide a traversal
// implementation (only for TyCtxt<'_> interners).
TrivialTypeTraversalImpls! {
- ::rustc_abi::FieldIdx,
- ::rustc_abi::VariantIdx,
- crate::middle::region::Scope,
- ::rustc_ast::InlineAsmOptions,
- ::rustc_ast::InlineAsmTemplatePiece,
- ::rustc_ast::NodeId,
- ::rustc_hir::def::Res,
- ::rustc_hir::def_id::LocalDefId,
- ::rustc_hir::ByRef,
- ::rustc_hir::HirId,
- ::rustc_hir::MatchSource,
- ::rustc_target::asm::InlineAsmRegOrRegClass,
- crate::mir::coverage::BlockMarkerId,
- crate::mir::coverage::CounterId,
- crate::mir::coverage::ExpressionId,
- crate::mir::coverage::ConditionId,
+ // tidy-alphabetical-start
+ crate::infer::canonical::Certainty,
+ crate::mir::BasicBlock,
+ crate::mir::BindingForm<'tcx>,
+ crate::mir::BlockTailInfo,
+ crate::mir::BorrowKind,
+ crate::mir::CastKind,
+ crate::mir::ConstValue<'tcx>,
+ crate::mir::CoroutineSavedLocal,
+ crate::mir::FakeReadCause,
crate::mir::Local,
+ crate::mir::MirPhase,
+ crate::mir::NullOp<'tcx>,
crate::mir::Promoted,
+ crate::mir::RawPtrKind,
+ crate::mir::RetagKind,
+ crate::mir::SourceInfo,
+ crate::mir::SourceScope,
+ crate::mir::SourceScopeLocalData,
+ crate::mir::SwitchTargets,
+ crate::traits::IsConstable,
+ crate::traits::OverflowError,
+ crate::ty::abstract_const::NotConstEvaluatable,
crate::ty::adjustment::AutoBorrowMutability,
+ crate::ty::adjustment::PointerCoercion,
crate::ty::AdtKind,
- crate::ty::BoundRegion,
- // Including `BoundRegionKind` is a *bit* dubious, but direct
- // references to bound region appear in `ty::Error`, and aren't
- // really meant to be folded. In general, we can only fold a fully
- // general `Region`.
- crate::ty::BoundRegionKind,
crate::ty::AssocItem,
crate::ty::AssocKind,
+ crate::ty::BoundRegion,
+ crate::ty::BoundVar,
crate::ty::Placeholder<crate::ty::BoundRegion>,
crate::ty::Placeholder<crate::ty::BoundTy>,
crate::ty::Placeholder<ty::BoundVar>,
- crate::ty::LateParamRegion,
- crate::ty::adjustment::PointerCoercion,
- ::rustc_span::Ident,
- ::rustc_span::Span,
- ::rustc_span::Symbol,
- ty::BoundVar,
- ty::ValTree<'tcx>,
+ crate::ty::UserTypeAnnotationIndex,
+ crate::ty::ValTree<'tcx>,
+ rustc_abi::FieldIdx,
+ rustc_abi::VariantIdx,
+ rustc_ast::InlineAsmOptions,
+ rustc_ast::InlineAsmTemplatePiece,
+ rustc_hir::CoroutineKind,
+ rustc_hir::def_id::LocalDefId,
+ rustc_hir::HirId,
+ rustc_hir::MatchSource,
+ rustc_span::Ident,
+ rustc_span::Span,
+ rustc_span::Symbol,
+ rustc_target::asm::InlineAsmRegOrRegClass,
+ // tidy-alphabetical-end
}
+
// For some things about which the type library does not know, or does not
// provide any traversal implementations, we need to provide a traversal
// implementation and a lift implementation (the former only for TyCtxt<'_>
// interners).
TrivialTypeTraversalAndLiftImpls! {
- ::rustc_hir::def_id::DefId,
- crate::ty::ClosureKind,
+ // tidy-alphabetical-start
+ crate::ty::instance::ReifyReason,
crate::ty::ParamConst,
crate::ty::ParamTy,
- crate::ty::instance::ReifyReason,
- interpret::AllocId,
- interpret::CtfeProvenance,
- interpret::Scalar,
- rustc_abi::Size,
-}
-
-TrivialLiftImpls! {
- ::rustc_hir::Safety,
- ::rustc_abi::ExternAbi,
+ rustc_hir::def_id::DefId,
+ // tidy-alphabetical-end
}
///////////////////////////////////////////////////////////////////////////
@@ -672,3 +688,39 @@ impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>> + Debug + Clone> TypeFoldable<TyCtxt<'t
})
}
}
+
+impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [InlineAsmTemplatePiece] {
+ fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
+ self,
+ _folder: &mut F,
+ ) -> Result<Self, F::Error> {
+ Ok(self)
+ }
+}
+
+impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [Span] {
+ fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
+ self,
+ _folder: &mut F,
+ ) -> Result<Self, F::Error> {
+ Ok(self)
+ }
+}
+
+impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<LocalDefId> {
+ fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
+ self,
+ _folder: &mut F,
+ ) -> Result<Self, F::Error> {
+ Ok(self)
+ }
+}
+
+impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<PlaceElem<'tcx>> {
+ fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
+ self,
+ folder: &mut F,
+ ) -> Result<Self, F::Error> {
+ ty::util::fold_list(self, folder, |tcx, v| tcx.mk_place_elems(v))
+ }
+}
diff --git a/compiler/rustc_type_ir/src/macros.rs b/compiler/rustc_type_ir/src/macros.rs
index aae5aeb5fb363..fab1a11304d57 100644
--- a/compiler/rustc_type_ir/src/macros.rs
+++ b/compiler/rustc_type_ir/src/macros.rs
@@ -47,23 +47,16 @@ TrivialTypeTraversalImpls! {
u16,
u32,
u64,
- String,
+ // tidy-alphabetical-start
crate::AliasRelationDirection,
- crate::AliasTyKind,
crate::BoundConstness,
crate::DebruijnIndex,
- crate::FloatTy,
- crate::InferTy,
- crate::IntVarValue,
crate::PredicatePolarity,
- crate::RegionVid,
crate::solve::BuiltinImplSource,
crate::solve::Certainty,
crate::solve::GoalSource,
- crate::solve::MaybeCause,
- crate::solve::NoSolution,
crate::UniverseIndex,
crate::Variance,
- rustc_ast_ir::Movability,
rustc_ast_ir::Mutability,
+ // tidy-alphabetical-end
}