Derive traversable impls for more type lib kinds

Author: eggyal

compiler/rustc_type_ir/src/canonical.rs

@@ -1,19 +1,16 @@
 use std::fmt;
 use std::hash::Hash;
-use std::ops::ControlFlow;
 
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_serialize::{Decodable, Encodable};
 
-use crate::fold::{FallibleTypeFolder, TypeFoldable};
-use crate::visit::{TypeVisitable, TypeVisitor};
 use crate::TyDecoder;
 use crate::{HashStableContext, Interner, TyEncoder, UniverseIndex};
 
 /// A "canonicalized" type `V` is one where all free inference
 /// variables have been rewritten to "canonical vars". These are
 /// numbered starting from 0 in order of first appearance.
-#[derive(derivative::Derivative)]
+#[derive(derivative::Derivative, TypeFoldable, TypeVisitable)]
 #[derivative(Clone(bound = "V: Clone"), Hash(bound = "V: Hash"))]
 pub struct Canonical<I: Interner, V> {
     pub value: V,
@@ -104,30 +101,6 @@ impl<I: Interner, V: fmt::Debug> fmt::Debug for Canonical<I, V> {
 
 impl<I: Interner, V: Copy> Copy for Canonical<I, V> where I::CanonicalVars: Copy {}
 
-impl<I: Interner, V: TypeFoldable<I>> TypeFoldable<I> for Canonical<I, V>
-where
-    I::CanonicalVars: TypeFoldable<I>,
-{
-    fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
-        Ok(Canonical {
-            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))?,
-        })
-    }
-}
-
-impl<I: Interner, V: TypeVisitable<I>> TypeVisitable<I> for Canonical<I, V>
-where
-    I::CanonicalVars: TypeVisitable<I>,
-{
-    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))
-    }
-}
-
 impl<I: Interner, E: TyEncoder<I = I>, V: Encodable<E>> Encodable<E> for Canonical<I, V>
 where
     I::CanonicalVars: Encodable<E>,

compiler/rustc_type_ir/src/predicate_kind.rs

@@ -2,16 +2,13 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_serialize::Decoder;
 use rustc_serialize::{Decodable, Encodable};
 use std::fmt;
-use std::ops::ControlFlow;
 
-use crate::fold::{FallibleTypeFolder, TypeFoldable};
-use crate::visit::{TypeVisitable, TypeVisitor};
-use crate::{HashStableContext, Interner, BoringTraversable};
+use crate::{HashStableContext, Interner};
 use crate::{TyDecoder, TyEncoder};
 
 /// A clause is something that can appear in where bounds or be inferred
 /// by implied bounds.
-#[derive(derivative::Derivative)]
+#[derive(derivative::Derivative, TypeFoldable, TypeVisitable)]
 #[derivative(Clone(bound = ""), Hash(bound = ""))]
 pub enum ClauseKind<I: Interner> {
     /// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be
@@ -108,80 +105,6 @@ where
     }
 }
 
-impl<I: Interner> TypeFoldable<I> for ClauseKind<I>
-where
-    I::Ty: TypeFoldable<I>,
-    I::Const: TypeFoldable<I>,
-    I::GenericArg: TypeFoldable<I>,
-    I::TraitPredicate: TypeFoldable<I>,
-    I::ProjectionPredicate: TypeFoldable<I>,
-    I::TypeOutlivesPredicate: TypeFoldable<I>,
-    I::RegionOutlivesPredicate: TypeFoldable<I>,
-{
-    fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
-        Ok(match self {
-            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::ConstEvaluatable(p) => {
-                ClauseKind::ConstEvaluatable(noop_traversal_if_boring!(p.try_fold_with(folder))?)
-            }
-        })
-    }
-}
-
-impl<I: Interner> TypeVisitable<I> for ClauseKind<I>
-where
-    I::Ty: TypeVisitable<I>,
-    I::Const: TypeVisitable<I>,
-    I::GenericArg: TypeVisitable<I>,
-    I::TraitPredicate: TypeVisitable<I>,
-    I::ProjectionPredicate: TypeVisitable<I>,
-    I::TypeOutlivesPredicate: TypeVisitable<I>,
-    I::RegionOutlivesPredicate: TypeVisitable<I>,
-{
-    fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
-        match self {
-            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) => {
-                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))
-            }
-        }
-    }
-}
-
 impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for ClauseKind<I>
 where
     I::Ty: Decodable<D>,
@@ -239,19 +162,23 @@ where
     }
 }
 
-#[derive(derivative::Derivative)]
+#[derive(derivative::Derivative, TypeFoldable, TypeVisitable)]
 #[derivative(Clone(bound = ""), Hash(bound = ""))]
 pub enum PredicateKind<I: Interner> {
     /// Prove a clause
     Clause(ClauseKind<I>),
 
     /// Trait must be object-safe.
-    ObjectSafe(I::DefId),
+    ObjectSafe(#[skip_traversal(because_boring)] I::DefId),
 
     /// No direct syntax. May be thought of as `where T: FnFoo<...>`
     /// for some generic args `...` and `T` being a closure type.
     /// Satisfied (or refuted) once we know the closure's kind.
-    ClosureKind(I::DefId, I::GenericArgs, I::ClosureKind),
+    ClosureKind(
+        #[skip_traversal(because_boring)] I::DefId,
+        I::GenericArgs,
+        #[skip_traversal(because_boring)] I::ClosureKind,
+    ),
 
     /// `T1 <: T2`
     ///
@@ -368,90 +295,6 @@ where
     }
 }
 
-impl<I: Interner> TypeFoldable<I> for PredicateKind<I>
-where
-    I::DefId: BoringTraversable,
-    I::Const: TypeFoldable<I>,
-    I::GenericArgs: TypeFoldable<I>,
-    I::Term: TypeFoldable<I>,
-    I::CoercePredicate: TypeFoldable<I>,
-    I::SubtypePredicate: TypeFoldable<I>,
-    I::ClosureKind: BoringTraversable,
-    ClauseKind<I>: TypeFoldable<I>,
-{
-    fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
-        Ok(match self {
-            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(
-                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(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(
-                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))?,
-            ),
-        })
-    }
-}
-
-impl<I: Interner> TypeVisitable<I> for PredicateKind<I>
-where
-    I::DefId: BoringTraversable,
-    I::Const: TypeVisitable<I>,
-    I::GenericArgs: TypeVisitable<I>,
-    I::Term: TypeVisitable<I>,
-    I::CoercePredicate: TypeVisitable<I>,
-    I::SubtypePredicate: TypeVisitable<I>,
-    I::ClosureKind: BoringTraversable,
-    ClauseKind<I>: TypeVisitable<I>,
-{
-    fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
-        match self {
-            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) => {
-                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::Coerce(s) => noop_traversal_if_boring!(s.visit_with(visitor)),
-            PredicateKind::ConstEquate(a, b) => {
-                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) => {
-                noop_traversal_if_boring!(a.visit_with(visitor))?;
-                noop_traversal_if_boring!(b.visit_with(visitor))?;
-                noop_traversal_if_boring!(d.visit_with(visitor))
-            }
-        }
-    }
-}
-
 impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for PredicateKind<I>
 where
     I::DefId: Decodable<D>,