more nits

Author: basil-cow

chalk-ir/src/visit.rs

@@ -12,12 +12,32 @@ pub mod visitors;
 
 pub use visitors::VisitExt;
 
+/// A "result type" that can be returned from a visitor. Visitors pick
+/// an appropriate result type depending on what sort of operation they
+/// are doing. A common choice is `FindAny`, which indicates that the visitor
+/// is searching for something and that the visitor should stop once it is found.
 pub trait VisitResult: Sized {
     fn new() -> Self;
 
+    /// Returns true if this result is "complete" and we can stop visiting any
+    /// further parts of the term. This is used by `FindAny`, for example, to
+    /// stop the search after a match has been found.
     fn return_early(&self) -> bool;
     fn combine(self, other: Self) -> Self;
 
+    /// Convenience helper for use in writing `Visitor` impls. Returns `self`
+    /// if `return_early()` is true, but otherwise combines `self` with the
+    /// result of invoking `op`.
+    ///
+    /// If you have a struct with two fields, `foo` and `bar`, you can
+    /// thus write code like
+    ///
+    /// ```rust,ignore
+    /// self.foo.visit_with(visitor, outer_binder)
+    ///     .and_then(|| self.bar.visit_with(visitor, outer_binder))
+    /// ```
+    ///
+    /// and `bar` will only be visited if necessary.
     fn and_then(self, op: impl FnOnce() -> Self) -> Self {
         if self.return_early() {
             self
@@ -27,6 +47,8 @@ pub trait VisitResult: Sized {
     }
 }
 
+/// Unit type for a visitor indicates a "side-effecting" visitor that
+/// should visit an entire term.
 impl VisitResult for () {
     fn new() -> () {}
 

chalk-ir/src/visit/boring_impls.rs

@@ -6,21 +6,22 @@
 
 use crate::{
     AssocTypeId, DebruijnIndex, Goals, ImplId, Interner, Parameter, ParameterKind,
-    PlaceholderIndex, ProgramClause, ProgramClauseData, ProgramClauses, QuantifierKind, StructId,
-    Substitution, SuperVisit, TraitId, UniverseIndex, Visit, VisitResult, Visitor,
+    PlaceholderIndex, ProgramClause, ProgramClauseData, ProgramClauses, QuantifiedWhereClauses,
+    QuantifierKind, StructId, Substitution, SuperVisit, TraitId, UniverseIndex, Visit, VisitResult,
+    Visitor,
 };
 use chalk_engine::{context::Context, ExClause, FlounderedSubgoal, Literal};
 use std::{marker::PhantomData, sync::Arc};
 
-pub fn visit_iter<'i, T, I, IT, R>(
-    it: IT,
+/// Convenience function to visit all the items in the iterator it.
+pub fn visit_iter<'i, T, I, R>(
+    it: impl Iterator<Item = T>,
     visitor: &mut dyn Visitor<'i, I, Result = R>,
     outer_binder: DebruijnIndex,
 ) -> R
 where
     T: Visit<I>,
     I: 'i + Interner,
-    IT: Iterator<Item = T>,
     R: VisitResult,
 {
     let mut result = R::new();
@@ -262,6 +263,21 @@ impl<I: Interner> Visit<I> for ProgramClauses<I> {
     }
 }
 
+impl<I: Interner> Visit<I> for QuantifiedWhereClauses<I> {
+    fn visit_with<'i, R: VisitResult>(
+        &self,
+        visitor: &mut dyn Visitor<'i, I, Result = R>,
+        outer_binder: DebruijnIndex,
+    ) -> R
+    where
+        I: 'i,
+    {
+        let interner = visitor.interner();
+
+        visit_iter(self.iter(interner), visitor, outer_binder)
+    }
+}
+
 impl<I: Interner> Visit<I> for PhantomData<I> {
     fn visit_with<'i, R: VisitResult>(
         &self,

chalk-ir/src/visit/visitors.rs

@@ -12,12 +12,14 @@ pub trait VisitExt<I: Interner>: Visit<I> {
 
 impl<T, I: Interner> VisitExt<I> for T where T: Visit<I> {}
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct FindAny {
     pub found: bool,
 }
 
 impl FindAny {
+    pub const FOUND: FindAny = FindAny { found: true };
+
     pub fn to_bool(&self) -> bool {
         self.found
     }
@@ -38,8 +40,8 @@ impl VisitResult for FindAny {
     }
 }
 
-pub struct FindFreeVarsVisitor<'i, I: Interner> {
-    pub interner: &'i I,
+struct FindFreeVarsVisitor<'i, I: Interner> {
+    interner: &'i I,
 }
 
 impl<'i, I: Interner> Visitor<'i, I> for FindFreeVarsVisitor<'i, I> {
@@ -58,14 +60,14 @@ impl<'i, I: Interner> Visitor<'i, I> for FindFreeVarsVisitor<'i, I> {
         _bound_var: BoundVar,
         _outer_binder: DebruijnIndex,
     ) -> Self::Result {
-        FindAny { found: true }
+        FindAny::FOUND
     }
 
     fn visit_free_var_lifetime(
         &mut self,
         _bound_var: BoundVar,
         _outer_binder: DebruijnIndex,
     ) -> Self::Result {
-        FindAny { found: true }
+        FindAny::FOUND
     }
 }

chalk-solve/src/wf.rs

@@ -177,7 +177,12 @@ where
                     let types =
                         InputTypeCollector::types_in(gb.interner(), (&fields, &where_clauses));
 
-                    gb.all(types.into_iter().map(|ty| ty.well_formed()).chain(sized_constraint_goal.into_iter()))
+                    gb.all(
+                        types
+                            .into_iter()
+                            .map(|ty| ty.well_formed().cast(interner))
+                            .chain(sized_constraint_goal.into_iter()),
+                    )
                 },
             )
         });