fix some nits

Author: basil-cow

chalk-ir/src/fold.rs

@@ -87,7 +87,7 @@ where
     /// Top-level callback: invoked for each `Lifetime<I>` that is
     /// encountered when folding. By default, invokes
     /// `super_fold_with`, which will in turn invoke the more
-    /// specialized folding methods below, like `fold_free_lifetime_ty`.
+    /// specialized folding methods below, like `fold_free_var_lifetime`.
     fn fold_lifetime(
         &mut self,
         lifetime: &Lifetime<I>,
@@ -99,7 +99,7 @@ where
     /// Top-level callback: invoked for each `Const<I>` that is
     /// encountered when folding. By default, invokes
     /// `super_fold_with`, which will in turn invoke the more
-    /// specialized folding methods below, like `fold_free_lifetime_ty`.
+    /// specialized folding methods below, like `fold_free_var_const`.
     fn fold_const(
         &mut self,
         constant: &Const<I>,
@@ -187,8 +187,8 @@ where
         }
     }
 
-    /// If overriden to return true, we will panic when a free
-    /// placeholder type/lifetime is encountered.
+    /// If overridden to return true, we will panic when a free
+    /// placeholder type/lifetime/const is encountered.
     fn forbid_free_placeholders(&self) -> bool {
         false
     }
@@ -234,7 +234,7 @@ where
         outer_binder: DebruijnIndex,
     ) -> Fallible<Const<TI>> {
         if self.forbid_free_placeholders() {
-            panic!("unexpected placeholder lifetime `{:?}`", universe)
+            panic!("unexpected placeholder const `{:?}`", universe)
         } else {
             Ok(universe.to_const(self.target_interner()))
         }
@@ -497,7 +497,6 @@ where
     I: Interner,
     TI: TargetInterner<I>,
 {
-    #[allow(unused_variables)]
     fn super_fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,

chalk-ir/src/fold/subst.rs

@@ -28,30 +28,30 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> {
         self
     }
 
+    /// We are eliminating one binder, but binders outside of that get preserved.
+    ///
+    /// So e.g. consider this:
+    ///
+    /// ```notrust
+    /// for<A, B> { for<C> { [A, C] } }
+    /// //          ^ the binder we are substituing with `[u32]`
+    /// ```
+    ///
+    /// Here, `A` would be `^1.0` and `C` would be `^0.0`. We will replace `^0.0` with the
+    /// 0th index from the list (`u32`). We will convert `^1.0` (A) to `^0.0` -- i.e., shift
+    /// it **out** of one level of binder (the `for<C>` binder we are eliminating).
+    ///
+    /// This gives us as a result:
+    ///
+    /// ```notrust
+    /// for<A, B> { [A, u32] }
+    ///              ^ represented as `^0.0`
+    /// ```
     fn fold_free_var_ty(
         &mut self,
         bound_var: BoundVar,
         outer_binder: DebruijnIndex,
     ) -> Fallible<Ty<I>> {
-        // We are eliminating one binder, but binders outside of that get preserved.
-        //
-        // So e.g. consider this:
-        //
-        // ```
-        // for<A, B> { for<C> { [A, C] } }
-        // //          ^ the binder we are substituing with `[u32]`
-        // ```
-        //
-        // Here, `A` would be `^1.0` and `C` would be `^0.0`. We will replace `^0.0` with the
-        // 0th index from the list (`u32`). We will convert `^1.0` (A) to `^0.0` -- i.e., shift
-        // it **out** of one level of binder (the `for<C>` binder we are eliminating).
-        //
-        // This gives us as a result:
-        //
-        // ```
-        // for<A, B> { [A, u32] }
-        //              ^ represented as `^0.0`
-        // ```
         if let Some(index) = bound_var.index_if_innermost() {
             match self.parameters[index].data(self.interner()) {
                 ParameterKind::Ty(t) => Ok(t.shifted_in_from(self.interner(), outer_binder)),
@@ -66,13 +66,12 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> {
         }
     }
 
+    /// see `fold_free_var_ty`
     fn fold_free_var_lifetime(
         &mut self,
         bound_var: BoundVar,
         outer_binder: DebruijnIndex,
     ) -> Fallible<Lifetime<I>> {
-        // see comment in `fold_free_var_ty`
-
         if let Some(index) = bound_var.index_if_innermost() {
             match self.parameters[index].data(self.interner()) {
                 ParameterKind::Lifetime(l) => Ok(l.shifted_in_from(self.interner(), outer_binder)),
@@ -87,13 +86,12 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> {
         }
     }
 
+    /// see `fold_free_var_ty`
     fn fold_free_var_const(
         &mut self,
         bound_var: BoundVar,
         outer_binder: DebruijnIndex,
     ) -> Fallible<Const<I>> {
-        // see comment in `fold_free_var_ty`
-
         if let Some(index) = bound_var.index_if_innermost() {
             match self.parameters[index].data(self.interner()) {
                 ParameterKind::Const(c) => Ok(c.shifted_in_from(self.interner(), outer_binder)),

chalk-ir/src/interner.rs

@@ -517,11 +517,11 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
 
     /// Create an "interned" const from `const`. This is not
     /// normally invoked directly; instead, you invoke
-    /// `LifetimeData::intern` (which will ultimately call this
+    /// `ConstData::intern` (which will ultimately call this
     /// method).
     fn intern_const(&self, constant: ConstData<Self>) -> Self::InternedConst;
 
-    /// Lookup the `ConstData` that was interned to create a `InternedLifetime`.
+    /// Lookup the `ConstData` that was interned to create a `InternedConst`.
     fn const_data<'a>(&self, constant: &'a Self::InternedConst) -> &'a ConstData<Self>;
 
     fn const_eq(&self, c1: &Self::InternedConcreteConst, c2: &Self::InternedConcreteConst) -> bool;

chalk-ir/src/lib.rs

@@ -686,7 +686,7 @@ impl<I: Interner> Const<I> {
         }
     }
 
-    /// True if this lifetime is a "bound" lifetime, and hence
+    /// True if this const is a "bound" const, and hence
     /// needs to be shifted across binders. Meant for debug assertions.
     pub fn needs_shift(&self, interner: &I) -> bool {
         match self.data(interner) {
@@ -718,7 +718,7 @@ pub struct ConcreteConst<I: Interner> {
 }
 
 impl<I: Interner> ConcreteConst<I> {
-    pub fn c_eq(&self, other: &ConcreteConst<I>, interner: &I) -> bool {
+    pub fn const_eq(&self, other: &ConcreteConst<I>, interner: &I) -> bool {
         interner.const_eq(&self.interned, &other.interned)
     }
 }

chalk-ir/src/visit.rs

@@ -134,7 +134,7 @@ where
 
     /// If overridden to return true, then visiting will panic if a
     /// free variable is encountered. This should be done if free
-    /// type/lifetime variables are not expected.
+    /// type/lifetime/const variables are not expected.
     fn forbid_free_vars(&self) -> bool {
         false
     }
@@ -211,7 +211,7 @@ where
         Self::Result::new()
     }
 
-    /// If overriden to return true, we will panic when a free
+    /// If overridden to return true, we will panic when a free
     /// placeholder type/lifetime is encountered.
     fn forbid_free_placeholders(&self) -> bool {
         false
@@ -258,7 +258,7 @@ where
         _outer_binder: DebruijnIndex,
     ) -> Self::Result {
         if self.forbid_free_placeholders() {
-            panic!("unexpected placeholder lifetime `{:?}`", universe)
+            panic!("unexpected placeholder const `{:?}`", universe)
         } else {
             Self::Result::new()
         }
@@ -445,7 +445,6 @@ impl<I: Interner> Visit<I> for Const<I> {
 }
 
 impl<I: Interner> SuperVisit<I> for Const<I> {
-    #[allow(unused_variables)]
     fn super_visit_with<'i, R: VisitResult>(
         &self,
         visitor: &mut dyn Visitor<'i, I, Result = R>,

chalk-solve/src/infer.rs

@@ -142,15 +142,11 @@ impl<I: Interner> InferenceTable<I> {
     }
 
     /// If type `leaf` is a free inference variable, and that variable has been
-    /// bound, returns `Some(T)` where `T` is the type to which it has been bound.
-    ///
-    /// `binders` is the number of binders under which `leaf` appears;
-    /// the return value will also be shifted accordingly so that it
-    /// can appear under that same number of binders.
+    /// bound, returns `Some(P)` where `P` is the parameter to which it has been bound.
     pub(crate) fn probe_var(&mut self, leaf: InferenceVar) -> Option<Parameter<I>> {
         match self.unify.probe_value(EnaVariable::from(leaf)) {
             InferenceValue::Unbound(_) => None,
-            InferenceValue::Bound(ref val) => Some(val.clone()),
+            InferenceValue::Bound(val) => Some(val),
         }
     }
 

chalk-solve/src/infer/instantiate.rs

@@ -96,7 +96,7 @@ impl<I: Interner> InferenceTable<I> {
                         lt.cast(interner)
                     }
                     ParameterKind::Ty(()) => placeholder_idx.to_ty(interner).cast(interner),
-                    ParameterKind::Const(_) => placeholder_idx.to_const(interner).cast(interner),
+                    ParameterKind::Const(()) => placeholder_idx.to_const(interner).cast(interner),
                 }
             })
             .collect();

chalk-solve/src/infer/unify.rs

@@ -383,7 +383,7 @@ impl<'t, I: Interner> Unifier<'t, I> {
             }
 
             (&ConstData::Concrete(ref ev1), &ConstData::Concrete(ref ev2)) => {
-                if ev1.c_eq(ev2, interner) {
+                if ev1.const_eq(ev2, interner) {
                     Ok(())
                 } else {
                     Err(NoSolution)

chalk-solve/src/solve/slg.rs

@@ -466,7 +466,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
         }
     }
 
-    // Returns true if the two types could be unequal.
+    /// Returns true if the two types could be unequal.
     fn aggregate_tys(&mut self, new: &Ty<I>, current: &Ty<I>) -> bool {
         let interner = self.interner;
         match (new.data(interner), current.data(interner)) {
@@ -530,11 +530,12 @@ impl<I: Interner> MayInvalidate<'_, I> {
         }
     }
 
+    /// Returns true if the two consts could be unequal.    
     fn aggregate_lifetimes(&mut self, _: &Lifetime<I>, _: &Lifetime<I>) -> bool {
         true
     }
 
-    // Returns true if the two consts could be unequal.
+    /// Returns true if the two consts could be unequal.
     fn aggregate_consts(&mut self, new: &Const<I>, current: &Const<I>) -> bool {
         let interner = self.interner;
         match (new.data(interner), current.data(interner)) {
@@ -559,7 +560,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
                 self.aggregate_placeholders(p1, p2)
             }
 
-            (ConstData::Concrete(c1), ConstData::Concrete(c2)) => !c1.c_eq(c2, interner),
+            (ConstData::Concrete(c1), ConstData::Concrete(c2)) => !c1.const_eq(c2, interner),
 
             // Only variants left are placeholder = concrete, which always fails
             (ConstData::Placeholder(_), _) | (ConstData::Concrete(_), _) => true,

chalk-solve/src/solve/slg/aggregate.rs

@@ -451,7 +451,7 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
                 }
             }
             (ConstData::Concrete(e1), ConstData::Concrete(e2)) => {
-                if e1.c_eq(e2, interner) {
+                if e1.const_eq(e2, interner) {
                     c1.clone()
                 } else {
                     self.new_const_variable()

chalk-solve/src/solve/slg/resolvent.rs

@@ -504,7 +504,7 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
             }
 
             (ConstData::Concrete(c1), ConstData::Concrete(c2)) => {
-                assert!(c1.c_eq(c2, interner));
+                assert!(c1.const_eq(c2, interner));
                 Ok(())
             }