Derive traversable impls for ConstKind

Author: eggyal

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_traversal_if_boring, 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_target::abi::TyAndLayout;
 use rustc_type_ir::{ConstKind, DebugWithInfcx, InferCtxtLike, WithInfcx};
@@ -721,33 +719,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_traversal_if_boring!(p.try_fold_with(folder))?)
-            }
-            ConstKind::Infer(i) => {
-                ConstKind::Infer(noop_traversal_if_boring!(i.try_fold_with(folder))?)
-            }
-            ConstKind::Bound(d, b) => ConstKind::Bound(
-                noop_traversal_if_boring!(d.try_fold_with(folder))?,
-                noop_traversal_if_boring!(b.try_fold_with(folder))?,
-            ),
-            ConstKind::Placeholder(p) => {
-                ConstKind::Placeholder(noop_traversal_if_boring!(p.try_fold_with(folder))?)
-            }
-            ConstKind::Unevaluated(uv) => {
-                ConstKind::Unevaluated(noop_traversal_if_boring!(uv.try_fold_with(folder))?)
-            }
-            ConstKind::Value(v) => {
-                ConstKind::Value(noop_traversal_if_boring!(v.try_fold_with(folder))?)
-            }
-            ConstKind::Error(e) => {
-                ConstKind::Error(noop_traversal_if_boring!(e.try_fold_with(folder))?)
-            }
-            ConstKind::Expr(e) => {
-                ConstKind::Expr(noop_traversal_if_boring!(e.try_fold_with(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 {
@@ -762,23 +734,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_traversal_if_boring!(p.visit_with(visitor)),
-            ConstKind::Infer(i) => noop_traversal_if_boring!(i.visit_with(visitor)),
-            ConstKind::Bound(d, b) => {
-                noop_traversal_if_boring!(d.visit_with(visitor))?;
-                noop_traversal_if_boring!(b.visit_with(visitor))
-            }
-            ConstKind::Placeholder(p) => {
-                noop_traversal_if_boring!(p.visit_with(visitor))
-            }
-            ConstKind::Unevaluated(uv) => {
-                noop_traversal_if_boring!(uv.visit_with(visitor))
-            }
-            ConstKind::Value(v) => noop_traversal_if_boring!(v.visit_with(visitor)),
-            ConstKind::Error(e) => noop_traversal_if_boring!(e.visit_with(visitor)),
-            ConstKind::Expr(e) => noop_traversal_if_boring!(e.visit_with(visitor)),
-        }
+        self.kind().visit_with(visitor)
     }
 }
 

compiler/rustc_type_ir/src/const_kind.rs

@@ -11,7 +11,7 @@ use crate::{
 use self::ConstKind::*;
 
 /// Represents a constant in Rust.
-#[derive(derivative::Derivative)]
+#[derive(derivative::Derivative, TypeFoldable, TypeVisitable)]
 #[derivative(
     Clone(bound = ""),
     PartialOrd(bound = ""),
@@ -22,28 +22,28 @@ use self::ConstKind::*;
 )]
 pub enum ConstKind<I: Interner> {
     /// A const generic parameter.
-    Param(I::ParamConst),
+    Param(#[skip_traversal(because_boring)] I::ParamConst),
 
     /// Infer the value of the const.
-    Infer(I::InferConst),
+    Infer(#[skip_traversal(because_boring)] I::InferConst),
 
     /// Bound const variable, used only when preparing a trait query.
-    Bound(DebruijnIndex, I::BoundConst),
+    Bound(DebruijnIndex, #[skip_traversal(because_boring)] I::BoundConst),
 
     /// A placeholder const - universally quantified higher-ranked const.
-    Placeholder(I::PlaceholderConst),
+    Placeholder(#[skip_traversal(because_boring)] I::PlaceholderConst),
 
     /// An unnormalized const item such as an anon const or assoc const or free const item.
     /// Right now anything other than anon consts does not actually work properly but this
     /// should
     Unevaluated(I::AliasConst),
 
     /// Used to hold computed value.
-    Value(I::ValueConst),
+    Value(#[skip_traversal(because_boring)] I::ValueConst),
 
     /// A placeholder for a const which could not be computed; this is
     /// propagated to avoid useless error messages.
-    Error(I::ErrorGuaranteed),
+    Error(#[skip_traversal(because_boring)] I::ErrorGuaranteed),
 
     /// Unevaluated non-const-item, used by `feature(generic_const_exprs)` to represent
     /// const arguments such as `N + 1` or `foo(N)`

compiler/rustc_type_ir/src/lib.rs

@@ -15,6 +15,7 @@
 extern crate bitflags;
 #[macro_use]
 extern crate rustc_macros;
+extern crate self as rustc_type_ir;
 
 use std::fmt;
 use std::hash::Hash;