Rename Visit to TypeVisitable

Author: eggyal

chalk-derive/src/lib.rs

@@ -118,7 +118,7 @@ enum DeriveKind {
 }
 
 decl_derive!([HasInterner, attributes(has_interner)] => derive_has_interner);
-decl_derive!([Visit, attributes(has_interner)] => derive_visit);
+decl_derive!([TypeVisitable, attributes(has_interner)] => derive_type_visitable);
 decl_derive!([SuperVisit, attributes(has_interner)] => derive_super_visit);
 decl_derive!([TypeFoldable, attributes(has_interner)] => derive_type_foldable);
 decl_derive!([Zip, attributes(has_interner)] => derive_zip);
@@ -136,24 +136,28 @@ fn derive_has_interner(mut s: synstructure::Structure) -> TokenStream {
     )
 }
 
-/// Derives Visit for structs and enums for which one of the following is true:
+/// Derives TypeVisitable for structs and enums for which one of the following is true:
 /// - It has a `#[has_interner(TheInterner)]` attribute
 /// - There is a single parameter `T: HasInterner` (does not have to be named `T`)
 /// - There is a single parameter `I: Interner` (does not have to be named `I`)
-fn derive_visit(s: synstructure::Structure) -> TokenStream {
-    derive_any_visit(s, parse_quote! { Visit }, parse_quote! { visit_with })
+fn derive_type_visitable(s: synstructure::Structure) -> TokenStream {
+    derive_any_type_visitable(
+        s,
+        parse_quote! { TypeVisitable },
+        parse_quote! { visit_with },
+    )
 }
 
-/// Same as Visit, but derives SuperVisit instead
+/// Same as TypeVisitable, but derives SuperVisit instead
 fn derive_super_visit(s: synstructure::Structure) -> TokenStream {
-    derive_any_visit(
+    derive_any_type_visitable(
         s,
         parse_quote! { SuperVisit },
         parse_quote! { super_visit_with },
     )
 }
 
-fn derive_any_visit(
+fn derive_any_type_visitable(
     mut s: synstructure::Structure,
     trait_name: Ident,
     method_name: Ident,
@@ -164,13 +168,13 @@ fn derive_any_visit(
 
     let body = s.each(|bi| {
         quote! {
-            ::chalk_ir::try_break!(::chalk_ir::visit::Visit::visit_with(#bi, visitor, outer_binder));
+            ::chalk_ir::try_break!(::chalk_ir::visit::TypeVisitable::visit_with(#bi, visitor, outer_binder));
         }
     });
 
     if kind == DeriveKind::FromHasInterner {
         let param = get_generic_param_name(input).unwrap();
-        s.add_where_predicate(parse_quote! { #param: ::chalk_ir::visit::Visit<#interner> });
+        s.add_where_predicate(parse_quote! { #param: ::chalk_ir::visit::TypeVisitable<#interner> });
     }
 
     s.add_bounds(synstructure::AddBounds::None);

chalk-engine/src/lib.rs

@@ -56,7 +56,7 @@
 use std::cmp::min;
 use std::usize;
 
-use chalk_derive::{HasInterner, TypeFoldable, Visit};
+use chalk_derive::{HasInterner, TypeFoldable, TypeVisitable};
 use chalk_ir::interner::Interner;
 use chalk_ir::{
     AnswerSubst, Canonical, ConstrainedSubst, Constraint, DebruijnIndex, Goal, InEnvironment,
@@ -84,7 +84,7 @@ index_struct! {
 }
 
 /// The paper describes these as `A :- D | G`.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct ExClause<I: Interner> {
     /// The substitution which, applied to the goal of our table,
     /// would yield A.
@@ -168,7 +168,7 @@ impl TimeStamp {
 ///
 /// trying to solve `?T: Foo` would immediately require solving `?T:
 /// Sized`, and hence would flounder.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable)]
 pub struct FlounderedSubgoal<I: Interner> {
     /// Literal that floundered.
     pub floundered_literal: Literal<I>,
@@ -209,7 +209,7 @@ pub struct CompleteAnswer<I: Interner> {
 }
 
 /// Either `A` or `~A`, where `A` is a `Env |- Goal`.
-#[derive(Clone, Debug, TypeFoldable, Visit)]
+#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
 pub enum Literal<I: Interner> {
     // FIXME: pub b/c fold
     Positive(InEnvironment<Goal<I>>),

chalk-ir/src/lib.rs

@@ -9,8 +9,8 @@ extern crate self as chalk_ir;
 use crate::cast::{Cast, CastTo, Caster};
 use crate::fold::shift::Shift;
 use crate::fold::{Folder, Subst, TypeFoldable, TypeSuperFoldable};
-use crate::visit::{SuperVisit, Visit, VisitExt, Visitor};
-use chalk_derive::{HasInterner, SuperVisit, TypeFoldable, Visit, Zip};
+use crate::visit::{SuperVisit, TypeVisitable, VisitExt, Visitor};
+use chalk_derive::{HasInterner, SuperVisit, TypeFoldable, TypeVisitable, Zip};
 use std::marker::PhantomData;
 use std::ops::ControlFlow;
 
@@ -147,7 +147,7 @@ impl Variance {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 /// The set of assumptions we've made so far, and the current number of
 /// universal (forall) quantifiers we're within.
 pub struct Environment<I: Interner> {
@@ -197,7 +197,7 @@ impl<I: Interner> Environment<I> {
 }
 
 /// A goal with an environment to solve it in.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable)]
 #[allow(missing_docs)]
 pub struct InEnvironment<G: HasInterner> {
     pub environment: Environment<G::Interner>,
@@ -1021,7 +1021,7 @@ impl DebruijnIndex {
 /// known. It is referenced within the type using `^1.0`, indicating
 /// a bound type with debruijn index 1 (i.e., skipping through one
 /// level of binder).
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct DynTy<I: Interner> {
     /// The unknown self type.
     pub bounds: Binders<QuantifiedWhereClauses<I>>,
@@ -1084,7 +1084,7 @@ pub struct FnSig<I: Interner> {
     pub variadic: bool,
 }
 /// A wrapper for the substs on a Fn.
-#[derive(Clone, PartialEq, Eq, Hash, HasInterner, TypeFoldable, Visit)]
+#[derive(Clone, PartialEq, Eq, Hash, HasInterner, TypeFoldable, TypeVisitable)]
 pub struct FnSubst<I: Interner>(pub Substitution<I>);
 
 impl<I: Interner> Copy for FnSubst<I> where I::InternedSubstitution: Copy {}
@@ -1516,7 +1516,7 @@ impl<I: Interner> GenericArg<I> {
 }
 
 /// Generic arguments data.
-#[derive(Clone, PartialEq, Eq, Hash, Visit, TypeFoldable, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeVisitable, TypeFoldable, Zip)]
 pub enum GenericArgData<I: Interner> {
     /// Type argument
     Ty(Ty<I>),
@@ -1601,7 +1601,7 @@ impl<I: Interner, T> WithKind<I, T> {
 pub type CanonicalVarKind<I: Interner> = WithKind<I, UniverseIndex>;
 
 /// An alias, which is a trait indirection such as a projection or opaque type.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 pub enum AliasTy<I: Interner> {
     /// An associated type projection.
     Projection(ProjectionTy<I>),
@@ -1631,7 +1631,7 @@ impl<I: Interner> AliasTy<I> {
 }
 
 /// A projection `<P0 as TraitName<P1..Pn>>::AssocItem<Pn+1..Pm>`.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct ProjectionTy<I: Interner> {
     /// The id for the associated type member.
     pub associated_ty_id: AssocTypeId<I>,
@@ -1653,7 +1653,7 @@ impl<I: Interner> ProjectionTy<I> {
 }
 
 /// An opaque type `opaque type T<..>: Trait = HiddenTy`.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct OpaqueTy<I: Interner> {
     /// The id for the opaque type.
     pub opaque_ty_id: OpaqueTyId<I>,
@@ -1669,7 +1669,7 @@ impl<I: Interner> Copy for OpaqueTy<I> where I::InternedSubstitution: Copy {}
 ///   implements the trait.
 /// - `<P0 as Trait<P1..Pn>>` (e.g. `i32 as Copy`), which casts the type to
 ///   that specific trait.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct TraitRef<I: Interner> {
     /// The trait id.
     pub trait_id: TraitId<I>,
@@ -1706,7 +1706,7 @@ impl<I: Interner> TraitRef<I> {
 
 /// Lifetime outlives, which for `'a: 'b`` checks that the lifetime `'a`
 /// is a superset of the value of `'b`.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 #[allow(missing_docs)]
 pub struct LifetimeOutlives<I: Interner> {
     pub a: Lifetime<I>,
@@ -1717,7 +1717,7 @@ impl<I: Interner> Copy for LifetimeOutlives<I> where I::InternedLifetime: Copy {
 
 /// Type outlives, which for `T: 'a` checks that the type `T`
 /// lives at least as long as the lifetime `'a`
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 pub struct TypeOutlives<I: Interner> {
     /// The type which must outlive the given lifetime.
     pub ty: Ty<I>,
@@ -1754,7 +1754,7 @@ where
 }
 
 /// Checks whether a type or trait ref is well-formed.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 pub enum WellFormed<I: Interner> {
     /// A predicate which is true when some trait ref is well-formed.
     /// For example, given the following trait definitions:
@@ -1792,7 +1792,7 @@ where
 }
 
 /// Checks whether a type or trait ref can be derived from the contents of the environment.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 pub enum FromEnv<I: Interner> {
     /// A predicate which enables deriving everything which should be true if we *know* that
     /// some trait ref is well-formed. For example given the above trait definitions, we can use
@@ -1990,7 +1990,7 @@ impl<I: Interner> DomainGoal<I> {
 }
 
 /// Equality goal: tries to prove that two values are equal.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, Zip)]
 #[allow(missing_docs)]
 pub struct EqGoal<I: Interner> {
     pub a: GenericArg<I>,
@@ -2000,7 +2000,7 @@ pub struct EqGoal<I: Interner> {
 impl<I: Interner> Copy for EqGoal<I> where I::InternedGenericArg: Copy {}
 
 /// Subtype goal: tries to prove that `a` is a subtype of `b`
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, Zip)]
 #[allow(missing_docs)]
 pub struct SubtypeGoal<I: Interner> {
     pub a: Ty<I>,
@@ -2013,7 +2013,7 @@ impl<I: Interner> Copy for SubtypeGoal<I> where I::InternedType: Copy {}
 /// type. A projection `T::Foo` normalizes to the type `U` if we can
 /// **match it to an impl** and that impl has a `type Foo = V` where
 /// `U = V`.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, Zip)]
 #[allow(missing_docs)]
 pub struct Normalize<I: Interner> {
     pub alias: AliasTy<I>,
@@ -2028,7 +2028,7 @@ where
 }
 
 /// Proves **equality** between an alias and a type.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, Zip)]
 #[allow(missing_docs)]
 pub struct AliasEq<I: Interner> {
     pub alias: AliasTy<I>,
@@ -2291,7 +2291,7 @@ where
 /// Represents one clause of the form `consequence :- conditions` where
 /// `conditions = cond_1 && cond_2 && ...` is the conjunction of the individual
 /// conditions.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 pub struct ProgramClauseImplication<I: Interner> {
     /// The consequence of the clause, which holds if the conditions holds.
     pub consequence: DomainGoal<I>,
@@ -2571,7 +2571,7 @@ where
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 /// A general goal; this is the full range of questions you can pose to Chalk.
 pub enum GoalData<I: Interner> {
     /// Introduces a binding at depth 0, shifting other bindings up
@@ -2654,7 +2654,7 @@ pub enum QuantifierKind {
 /// lifetime constraints, instead gathering them up to return with our solution
 /// for later checking. This allows for decoupling between type and region
 /// checking in the compiler.
-#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner, Zip)]
+#[derive(Clone, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner, Zip)]
 pub enum Constraint<I: Interner> {
     /// Outlives constraint `'a: 'b`, indicating that the value of `'a` must be
     /// a superset of the value of `'b`.
@@ -3037,7 +3037,7 @@ impl<I: Interner> Variances<I> {
 /// substitution stores the values for the query's unknown variables,
 /// and the constraints represents any region constraints that must
 /// additionally be solved.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct ConstrainedSubst<I: Interner> {
     /// The substitution that is being constrained.
     ///
@@ -3049,7 +3049,7 @@ pub struct ConstrainedSubst<I: Interner> {
 }
 
 /// The resulting substitution after solving a goal.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct AnswerSubst<I: Interner> {
     /// The substitution result.
     ///

chalk-ir/src/visit.rs

@@ -30,7 +30,7 @@ macro_rules! try_break {
 /// such as a `Goal`, and computes a value as a result.
 ///
 ///
-/// To **apply** a visitor, use the `Visit::visit_with` method, like so
+/// To **apply** a visitor, use the `TypeVisitable::visit_with` method, like so
 ///
 /// ```rust,ignore
 /// let result = x.visit_with(&mut visitor, 0);
@@ -188,7 +188,7 @@ pub trait Visitor<I: Interner> {
 
 /// Applies the given `visitor` to a value, producing a visited result
 /// of type `Visitor::Result`.
-pub trait Visit<I: Interner>: Debug {
+pub trait TypeVisitable<I: Interner>: Debug {
     /// Apply the given visitor `visitor` to `self`; `binders` is the
     /// number of binders that are in scope when beginning the
     /// visitor. Typically `binders` starts as 0, but is adjusted when
@@ -204,7 +204,7 @@ pub trait Visit<I: Interner>: Debug {
 /// For types where "visit" invokes a callback on the `visitor`, the
 /// `SuperVisit` trait captures the recursive behavior that visits all
 /// the contents of the type.
-pub trait SuperVisit<I: Interner>: Visit<I> {
+pub trait SuperVisit<I: Interner>: TypeVisitable<I> {
     /// Recursively visits the type contents.
     fn super_visit_with<B>(
         &self,
@@ -216,7 +216,7 @@ pub trait SuperVisit<I: Interner>: Visit<I> {
 /// "visiting" a type invokes the `visit_ty` method on the visitor; this
 /// usually (in turn) invokes `super_visit_ty` to visit the individual
 /// parts.
-impl<I: Interner> Visit<I> for Ty<I> {
+impl<I: Interner> TypeVisitable<I> for Ty<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,
@@ -301,7 +301,7 @@ where
     }
 }
 
-impl<I: Interner> Visit<I> for Lifetime<I> {
+impl<I: Interner> TypeVisitable<I> for Lifetime<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,
@@ -338,7 +338,7 @@ impl<I: Interner> SuperVisit<I> for Lifetime<I> {
     }
 }
 
-impl<I: Interner> Visit<I> for Const<I> {
+impl<I: Interner> TypeVisitable<I> for Const<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,
@@ -372,7 +372,7 @@ impl<I: Interner> SuperVisit<I> for Const<I> {
     }
 }
 
-impl<I: Interner> Visit<I> for Goal<I> {
+impl<I: Interner> TypeVisitable<I> for Goal<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,
@@ -393,7 +393,7 @@ impl<I: Interner> SuperVisit<I> for Goal<I> {
     }
 }
 
-impl<I: Interner> Visit<I> for ProgramClause<I> {
+impl<I: Interner> TypeVisitable<I> for ProgramClause<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,
@@ -403,7 +403,7 @@ impl<I: Interner> Visit<I> for ProgramClause<I> {
     }
 }
 
-impl<I: Interner> Visit<I> for WhereClause<I> {
+impl<I: Interner> TypeVisitable<I> for WhereClause<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,
@@ -413,7 +413,7 @@ impl<I: Interner> Visit<I> for WhereClause<I> {
     }
 }
 
-impl<I: Interner> Visit<I> for DomainGoal<I> {
+impl<I: Interner> TypeVisitable<I> for DomainGoal<I> {
     fn visit_with<B>(
         &self,
         visitor: &mut dyn Visitor<I, BreakTy = B>,