Use specialisation in explicit traversable impls

Author: eggyal

compiler/rustc_middle/src/ty/mod.rs

@@ -1582,16 +1582,19 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ParamEnv<'tcx> {
         folder: &mut F,
     ) -> Result<Self, F::Error> {
         Ok(ParamEnv::new(
-            self.caller_bounds().try_fold_with(folder)?,
-            self.reveal().try_fold_with(folder)?,
+            rustc_type_ir::noop_traversal_if_boring!(
+                { self.caller_bounds() }.try_fold_with(folder)
+            )?,
+            rustc_type_ir::noop_traversal_if_boring!({ self.reveal() }.try_fold_with(folder))?,
         ))
     }
 }
 
 impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ParamEnv<'tcx> {
     fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
-        self.caller_bounds().visit_with(visitor)?;
-        self.reveal().visit_with(visitor)
+        rustc_type_ir::noop_traversal_if_boring!({ &self.caller_bounds() }.visit_with(visitor))?;
+        rustc_type_ir::noop_traversal_if_boring!({ &self.reveal() }.visit_with(visitor))?;
+        ControlFlow::Continue(())
     }
 }
 

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -7,7 +7,9 @@ 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, AliasTy, InferConst, Lift, Term, TermKind, Ty, TyCtxt};
+use crate::ty::{
+    self, noop_traversal_if_boring, 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};
@@ -770,16 +772,31 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
     ) -> Result<Self, F::Error> {
         let ty = self.ty().try_fold_with(folder)?;
         let kind = match self.kind() {
-            ConstKind::Param(p) => ConstKind::Param(p.try_fold_with(folder)?),
-            ConstKind::Infer(i) => ConstKind::Infer(i.try_fold_with(folder)?),
-            ConstKind::Bound(d, b) => {
-                ConstKind::Bound(d.try_fold_with(folder)?, b.try_fold_with(folder)?)
+            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))?)
             }
-            ConstKind::Placeholder(p) => ConstKind::Placeholder(p.try_fold_with(folder)?),
-            ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(uv.try_fold_with(folder)?),
-            ConstKind::Value(v) => ConstKind::Value(v.try_fold_with(folder)?),
-            ConstKind::Error(e) => ConstKind::Error(e.try_fold_with(folder)?),
-            ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?),
         };
         if ty != self.ty() || kind != self.kind() {
             Ok(folder.interner().mk_ct_from_kind(kind, ty))
@@ -795,18 +812,22 @@ 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) => p.visit_with(visitor),
-            ConstKind::Infer(i) => i.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) => {
-                d.visit_with(visitor)?;
-                b.visit_with(visitor)
+                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::Placeholder(p) => p.visit_with(visitor),
-            ConstKind::Unevaluated(uv) => uv.visit_with(visitor),
-            ConstKind::Value(v) => v.visit_with(visitor),
-            ConstKind::Error(e) => e.visit_with(visitor),
-            ConstKind::Expr(e) => e.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)),
         }
     }
 }

compiler/rustc_type_ir/src/canonical.rs

@@ -110,9 +110,9 @@ where
 {
     fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
         Ok(Canonical {
-            value: self.value.try_fold_with(folder)?,
-            max_universe: self.max_universe.try_fold_with(folder)?,
-            variables: self.variables.try_fold_with(folder)?,
+            value: noop_traversal_if_boring!({ self.value }.try_fold_with(folder))?,
+            max_universe: noop_traversal_if_boring!({ self.max_universe }.try_fold_with(folder))?,
+            variables: noop_traversal_if_boring!({ self.variables }.try_fold_with(folder))?,
         })
     }
 }
@@ -121,10 +121,10 @@ impl<I: Interner, V: TypeVisitable<I>> TypeVisitable<I> for Canonical<I, V>
 where
     I::CanonicalVars: TypeVisitable<I>,
 {
-    fn visit_with<F: TypeVisitor<I>>(&self, folder: &mut F) -> ControlFlow<F::BreakTy> {
-        self.value.visit_with(folder)?;
-        self.max_universe.visit_with(folder)?;
-        self.variables.visit_with(folder)
+    fn visit_with<F: TypeVisitor<I>>(&self, visitor: &mut F) -> ControlFlow<F::BreakTy> {
+        noop_traversal_if_boring!({ &self.value }.visit_with(visitor))?;
+        noop_traversal_if_boring!({ &self.max_universe }.visit_with(visitor))?;
+        noop_traversal_if_boring!({ &self.variables }.visit_with(visitor))
     }
 }
 

compiler/rustc_type_ir/src/predicate_kind.rs

@@ -120,16 +120,27 @@ where
 {
     fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
         Ok(match self {
-            ClauseKind::Trait(p) => ClauseKind::Trait(p.try_fold_with(folder)?),
-            ClauseKind::RegionOutlives(p) => ClauseKind::RegionOutlives(p.try_fold_with(folder)?),
-            ClauseKind::TypeOutlives(p) => ClauseKind::TypeOutlives(p.try_fold_with(folder)?),
-            ClauseKind::Projection(p) => ClauseKind::Projection(p.try_fold_with(folder)?),
-            ClauseKind::ConstArgHasType(c, t) => {
-                ClauseKind::ConstArgHasType(c.try_fold_with(folder)?, t.try_fold_with(folder)?)
+            ClauseKind::Trait(p) => {
+                ClauseKind::Trait(noop_traversal_if_boring!(p.try_fold_with(folder))?)
+            }
+            ClauseKind::RegionOutlives(p) => {
+                ClauseKind::RegionOutlives(noop_traversal_if_boring!(p.try_fold_with(folder))?)
+            }
+            ClauseKind::TypeOutlives(p) => {
+                ClauseKind::TypeOutlives(noop_traversal_if_boring!(p.try_fold_with(folder))?)
+            }
+            ClauseKind::Projection(p) => {
+                ClauseKind::Projection(noop_traversal_if_boring!(p.try_fold_with(folder))?)
+            }
+            ClauseKind::ConstArgHasType(c, t) => ClauseKind::ConstArgHasType(
+                noop_traversal_if_boring!(c.try_fold_with(folder))?,
+                noop_traversal_if_boring!(t.try_fold_with(folder))?,
+            ),
+            ClauseKind::WellFormed(p) => {
+                ClauseKind::WellFormed(noop_traversal_if_boring!(p.try_fold_with(folder))?)
             }
-            ClauseKind::WellFormed(p) => ClauseKind::WellFormed(p.try_fold_with(folder)?),
             ClauseKind::ConstEvaluatable(p) => {
-                ClauseKind::ConstEvaluatable(p.try_fold_with(folder)?)
+                ClauseKind::ConstEvaluatable(noop_traversal_if_boring!(p.try_fold_with(folder))?)
             }
         })
     }
@@ -147,16 +158,26 @@ where
 {
     fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
         match self {
-            ClauseKind::Trait(p) => p.visit_with(visitor),
-            ClauseKind::RegionOutlives(p) => p.visit_with(visitor),
-            ClauseKind::TypeOutlives(p) => p.visit_with(visitor),
-            ClauseKind::Projection(p) => p.visit_with(visitor),
+            ClauseKind::Trait(p) => noop_traversal_if_boring!(p.visit_with(visitor)),
+            ClauseKind::RegionOutlives(p) => {
+                noop_traversal_if_boring!(p.visit_with(visitor))
+            }
+            ClauseKind::TypeOutlives(p) => {
+                noop_traversal_if_boring!(p.visit_with(visitor))
+            }
+            ClauseKind::Projection(p) => {
+                noop_traversal_if_boring!(p.visit_with(visitor))
+            }
             ClauseKind::ConstArgHasType(c, t) => {
-                c.visit_with(visitor)?;
-                t.visit_with(visitor)
+                noop_traversal_if_boring!(c.visit_with(visitor))?;
+                noop_traversal_if_boring!(t.visit_with(visitor))
+            }
+            ClauseKind::WellFormed(p) => {
+                noop_traversal_if_boring!(p.visit_with(visitor))
+            }
+            ClauseKind::ConstEvaluatable(p) => {
+                noop_traversal_if_boring!(p.visit_with(visitor))
             }
-            ClauseKind::WellFormed(p) => p.visit_with(visitor),
-            ClauseKind::ConstEvaluatable(p) => p.visit_with(visitor),
         }
     }
 }
@@ -360,23 +381,32 @@ where
 {
     fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
         Ok(match self {
-            PredicateKind::Clause(c) => PredicateKind::Clause(c.try_fold_with(folder)?),
-            PredicateKind::ObjectSafe(d) => PredicateKind::ObjectSafe(d.try_fold_with(folder)?),
+            PredicateKind::Clause(c) => {
+                PredicateKind::Clause(noop_traversal_if_boring!(c.try_fold_with(folder))?)
+            }
+            PredicateKind::ObjectSafe(d) => {
+                PredicateKind::ObjectSafe(noop_traversal_if_boring!(d.try_fold_with(folder))?)
+            }
             PredicateKind::ClosureKind(d, g, k) => PredicateKind::ClosureKind(
-                d.try_fold_with(folder)?,
-                g.try_fold_with(folder)?,
-                k.try_fold_with(folder)?,
+                noop_traversal_if_boring!(d.try_fold_with(folder))?,
+                noop_traversal_if_boring!(g.try_fold_with(folder))?,
+                noop_traversal_if_boring!(k.try_fold_with(folder))?,
             ),
-            PredicateKind::Subtype(s) => PredicateKind::Subtype(s.try_fold_with(folder)?),
-            PredicateKind::Coerce(s) => PredicateKind::Coerce(s.try_fold_with(folder)?),
-            PredicateKind::ConstEquate(a, b) => {
-                PredicateKind::ConstEquate(a.try_fold_with(folder)?, b.try_fold_with(folder)?)
+            PredicateKind::Subtype(s) => {
+                PredicateKind::Subtype(noop_traversal_if_boring!(s.try_fold_with(folder))?)
             }
+            PredicateKind::Coerce(s) => {
+                PredicateKind::Coerce(noop_traversal_if_boring!(s.try_fold_with(folder))?)
+            }
+            PredicateKind::ConstEquate(a, b) => PredicateKind::ConstEquate(
+                noop_traversal_if_boring!(a.try_fold_with(folder))?,
+                noop_traversal_if_boring!(b.try_fold_with(folder))?,
+            ),
             PredicateKind::Ambiguous => PredicateKind::Ambiguous,
             PredicateKind::AliasRelate(a, b, d) => PredicateKind::AliasRelate(
-                a.try_fold_with(folder)?,
-                b.try_fold_with(folder)?,
-                d.try_fold_with(folder)?,
+                noop_traversal_if_boring!(a.try_fold_with(folder))?,
+                noop_traversal_if_boring!(b.try_fold_with(folder))?,
+                noop_traversal_if_boring!(d.try_fold_with(folder))?,
             ),
         })
     }
@@ -395,24 +425,28 @@ where
 {
     fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
         match self {
-            PredicateKind::Clause(p) => p.visit_with(visitor),
-            PredicateKind::ObjectSafe(d) => d.visit_with(visitor),
+            PredicateKind::Clause(p) => noop_traversal_if_boring!(p.visit_with(visitor)),
+            PredicateKind::ObjectSafe(d) => {
+                noop_traversal_if_boring!(d.visit_with(visitor))
+            }
             PredicateKind::ClosureKind(d, g, k) => {
-                d.visit_with(visitor)?;
-                g.visit_with(visitor)?;
-                k.visit_with(visitor)
+                noop_traversal_if_boring!(d.visit_with(visitor))?;
+                noop_traversal_if_boring!(g.visit_with(visitor))?;
+                noop_traversal_if_boring!(k.visit_with(visitor))
+            }
+            PredicateKind::Subtype(s) => {
+                noop_traversal_if_boring!(s.visit_with(visitor))
             }
-            PredicateKind::Subtype(s) => s.visit_with(visitor),
-            PredicateKind::Coerce(s) => s.visit_with(visitor),
+            PredicateKind::Coerce(s) => noop_traversal_if_boring!(s.visit_with(visitor)),
             PredicateKind::ConstEquate(a, b) => {
-                a.visit_with(visitor)?;
-                b.visit_with(visitor)
+                noop_traversal_if_boring!(a.visit_with(visitor))?;
+                noop_traversal_if_boring!(b.visit_with(visitor))
             }
             PredicateKind::Ambiguous => ControlFlow::Continue(()),
             PredicateKind::AliasRelate(a, b, d) => {
-                a.visit_with(visitor)?;
-                b.visit_with(visitor)?;
-                d.visit_with(visitor)
+                noop_traversal_if_boring!(a.visit_with(visitor))?;
+                noop_traversal_if_boring!(b.visit_with(visitor))?;
+                noop_traversal_if_boring!(d.visit_with(visitor))
             }
         }
     }