Derive traversable impls for ConstKind

Author: eggyal

compiler/rustc_middle/src/ty/consts/kind.rs

@@ -80,6 +80,10 @@ static_assert_size!(super::ConstKind<'_>, 32);
 
 /// An inference variable for a const, for use in const generics.
 #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable, Hash)]
+#[derive(TypeFoldable, TypeVisitable)]
+#[skip_traversal(
+    but_impl_despite_trivial_because = "traversed generically in `rustc_type_ir::ConstKind<TyCtxt>`"
+)]
 pub enum InferConst {
     /// Infer the value of the const.
     Var(ty::ConstVid),

compiler/rustc_middle/src/ty/consts/valtree.rs

@@ -17,6 +17,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 ///
 /// `ValTree` does not have this problem with representation, as it only contains integers or
 /// lists of (nested) `ValTree`.
+#[derive(TypeFoldable, TypeVisitable)]
 pub enum ValTree<'tcx> {
     /// integers, `bool`, `char` are represented as scalars.
     /// See the `ScalarInt` documentation for how `ScalarInt` guarantees that equal values

compiler/rustc_middle/src/ty/mod.rs

@@ -1527,7 +1527,7 @@ impl<'tcx> OpaqueHiddenType<'tcx> {
 /// regions/types/consts within the same universe simply have an unknown relationship to one
 /// another.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[derive(HashStable, TyEncodable, TyDecodable)]
+#[derive(HashStable, TyEncodable, TyDecodable, TypeFoldable, TypeVisitable)]
 pub struct Placeholder<T> {
     pub universe: UniverseIndex,
     pub bound: T,

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -7,9 +7,7 @@ use crate::mir::interpret;
 use crate::ty::fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable};
 use crate::ty::print::{with_no_trimmed_paths, FmtPrinter, Printer};
 use crate::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
-use crate::ty::{
-    self, noop_if_trivially_traversable, AliasTy, InferConst, Lift, Term, TermKind, Ty, TyCtxt,
-};
+use crate::ty::{self, AliasTy, InferConst, Lift, Term, TermKind, Ty, TyCtxt};
 use rustc_hir::def::Namespace;
 use rustc_span::source_map::Spanned;
 use rustc_type_ir::{ConstKind, DebugWithInfcx, InferCtxtLike, WithInfcx};
@@ -714,33 +712,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
         folder: &mut F,
     ) -> Result<Self, F::Error> {
         let ty = self.ty().try_fold_with(folder)?;
-        let kind = match self.kind() {
-            ConstKind::Param(p) => ConstKind::Param(noop_if_trivially_traversable!(
-                p.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-            ConstKind::Infer(i) => ConstKind::Infer(noop_if_trivially_traversable!(
-                i.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-            ConstKind::Bound(d, b) => ConstKind::Bound(
-                noop_if_trivially_traversable!(d.try_fold_with::<TyCtxt<'tcx>>(folder))?,
-                noop_if_trivially_traversable!(b.try_fold_with::<TyCtxt<'tcx>>(folder))?,
-            ),
-            ConstKind::Placeholder(p) => ConstKind::Placeholder(noop_if_trivially_traversable!(
-                p.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-            ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(noop_if_trivially_traversable!(
-                uv.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-            ConstKind::Value(v) => ConstKind::Value(noop_if_trivially_traversable!(
-                v.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-            ConstKind::Error(e) => ConstKind::Error(noop_if_trivially_traversable!(
-                e.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-            ConstKind::Expr(e) => ConstKind::Expr(noop_if_trivially_traversable!(
-                e.try_fold_with::<TyCtxt<'tcx>>(folder)
-            )?),
-        };
+        let kind = self.kind().try_fold_with(folder)?;
         if ty != self.ty() || kind != self.kind() {
             Ok(folder.interner().mk_ct_from_kind(kind, ty))
         } else {
@@ -755,33 +727,7 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Const<'tcx> {
         visitor: &mut V,
     ) -> ControlFlow<V::BreakTy> {
         self.ty().visit_with(visitor)?;
-        match &self.kind() {
-            ConstKind::Param(p) => {
-                noop_if_trivially_traversable!(p.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Infer(i) => {
-                noop_if_trivially_traversable!(i.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Bound(d, b) => {
-                noop_if_trivially_traversable!(d.visit_with::<TyCtxt<'tcx>>(visitor))?;
-                noop_if_trivially_traversable!(b.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Placeholder(p) => {
-                noop_if_trivially_traversable!(p.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Unevaluated(uv) => {
-                noop_if_trivially_traversable!(uv.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Value(v) => {
-                noop_if_trivially_traversable!(v.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Error(e) => {
-                noop_if_trivially_traversable!(e.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-            ConstKind::Expr(e) => {
-                noop_if_trivially_traversable!(e.visit_with::<TyCtxt<'tcx>>(visitor))
-            }
-        }
+        self.kind().visit_with(visitor)
     }
 }
 

compiler/rustc_middle/src/ty/sty.rs

@@ -1445,7 +1445,10 @@ impl<'tcx> ParamTy {
 }
 
 #[derive(Copy, Clone, Hash, TyEncodable, TyDecodable, Eq, PartialEq, Ord, PartialOrd)]
-#[derive(HashStable)]
+#[derive(HashStable, TypeFoldable, TypeVisitable)]
+#[skip_traversal(
+    but_impl_despite_trivial_because = "traversed generically in `rustc_type_ir::ConstKind<TyCtxt>`"
+)]
 pub struct ParamConst {
     pub index: u32,
     pub name: Symbol,
@@ -1618,7 +1621,8 @@ impl Atom for RegionVid {
 }
 
 rustc_index::newtype_index! {
-    #[derive(HashStable)]
+    #[derive(HashStable, TypeFoldable, TypeVisitable)]
+    #[skip_traversal(but_impl_despite_trivial_because = "traversed generically in `rustc_type_ir::ConstKind<TyCtxt>`")]
     #[debug_format = "{}"]
     pub struct BoundVar {}
 }

compiler/rustc_span/src/lib.rs

@@ -2247,7 +2247,10 @@ where
 /// The `()` field is necessary: it is non-`pub`, which means values of this
 /// type cannot be constructed outside of this crate.
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, TypeFoldable, TypeVisitable)]
+#[skip_traversal(
+    but_impl_despite_trivial_because = "traversed generically in `rustc_type_ir::ConstKind<TyCtxt>`"
+)]
 pub struct ErrorGuaranteed(());
 
 impl ErrorGuaranteed {

compiler/rustc_type_ir/src/const_kind.rs

@@ -7,7 +7,7 @@ use crate::{DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Int
 use self::ConstKind::*;
 
 /// Represents a constant in Rust.
-#[derive(derivative::Derivative)]
+#[derive(derivative::Derivative, TypeFoldable, TypeVisitable)]
 #[derivative(
     Clone(bound = ""),
     PartialOrd(bound = ""),