track outermost binder instead of number of binders

This is more strongly typed. In the process, rename `shifted_in_by/shifted_out_by` to

* `shifted_in_from(D)` -- i.e., we are shifting a value from the binder D into this one
* `shifted_out_to(D)` -- i.e., we are shifting a value from this binder into the binder D

I at least find those names give me a better intuition for what's going on in
most cases. i.e., we are taking a term that was valid from some outer binder D
and shifting it *in* to the inner binder.

Author: nikomatsakis

chalk-derive/src/lib.rs

@@ -33,7 +33,7 @@ pub fn derive_fold(item: TokenStream) -> TokenStream {
                 fn fold_with<'i>(
                     &self,
                     folder: &mut dyn Folder < 'i, #arg, #arg >,
-                    binders: usize,
+                    outer_binder: DebruijnIndex,
                 ) -> ::chalk_engine::fallible::Fallible<Self::Result> {
                     #body
                 }
@@ -97,7 +97,7 @@ pub fn derive_fold(item: TokenStream) -> TokenStream {
                 fn fold_with<'i>(
                     &self,
                     folder: &mut dyn Folder < 'i, _I, _TI >,
-                    binders: usize,
+                    outer_binder: DebruijnIndex,
                 ) -> ::chalk_engine::fallible::Fallible<Self::Result>
                 where
                     _I: 'i,
@@ -136,7 +136,7 @@ pub fn derive_fold(item: TokenStream) -> TokenStream {
                 fn fold_with<'i>(
                     &self,
                     folder: &mut dyn Folder < 'i, #i, _TI >,
-                    binders: usize,
+                    outer_binder: DebruijnIndex,
                 ) -> ::chalk_engine::fallible::Fallible<Self::Result>
                 where
                     #i: 'i,
@@ -157,7 +157,7 @@ fn derive_fold_body(type_name: &Ident, data: Data) -> proc_macro2::TokenStream {
         Data::Struct(s) => {
             let fields = s.fields.into_iter().map(|f| {
                 let name = f.ident.as_ref().expect("Unnamed field in Foldable struct");
-                quote! { #name: self.#name.fold_with(folder, binders)? }
+                quote! { #name: self.#name.fold_with(folder, outer_binder)? }
             });
             quote! {
                 Ok(#type_name {
@@ -187,7 +187,7 @@ fn derive_fold_body(type_name: &Ident, data: Data) -> proc_macro2::TokenStream {
                             .collect();
                         quote! {
                             #type_name::#variant( #(ref #names),* ) => {
-                                Ok(#type_name::#variant( #(#names.fold_with(folder, binders)?),* ))
+                                Ok(#type_name::#variant( #(#names.fold_with(folder, outer_binder)?),* ))
                             }
                         }
                     }

chalk-ir/src/debug.rs

@@ -135,7 +135,7 @@ impl<I: Interner> Debug for TyData<I> {
 }
 
 impl Debug for BoundVar {
-    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         let BoundVar { debruijn, index } = self;
         write!(fmt, "{:?}.{:?}", debruijn, index)
     }

chalk-ir/src/fold.rs

@@ -80,30 +80,34 @@ where
     /// encountered when folding. By default, invokes
     /// `super_fold_with`, which will in turn invoke the more
     /// specialized folding methods below, like `fold_free_var_ty`.
-    fn fold_ty(&mut self, ty: &Ty<I>, binders: usize) -> Fallible<Ty<TI>> {
-        ty.super_fold_with(self.as_dyn(), binders)
+    fn fold_ty(&mut self, ty: &Ty<I>, outer_binder: DebruijnIndex) -> Fallible<Ty<TI>> {
+        ty.super_fold_with(self.as_dyn(), outer_binder)
     }
 
     /// 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`.
-    fn fold_lifetime(&mut self, lifetime: &Lifetime<I>, binders: usize) -> Fallible<Lifetime<TI>> {
-        lifetime.super_fold_with(self.as_dyn(), binders)
+    fn fold_lifetime(
+        &mut self,
+        lifetime: &Lifetime<I>,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Lifetime<TI>> {
+        lifetime.super_fold_with(self.as_dyn(), outer_binder)
     }
 
     /// Invoked for every program clause. By default, recursively folds the goals contents.
     fn fold_program_clause(
         &mut self,
         clause: &ProgramClause<I>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<ProgramClause<TI>> {
-        clause.super_fold_with(self.as_dyn(), binders)
+        clause.super_fold_with(self.as_dyn(), outer_binder)
     }
 
     /// Invoked for every goal. By default, recursively folds the goals contents.
-    fn fold_goal(&mut self, goal: &Goal<I>, binders: usize) -> Fallible<Goal<TI>> {
-        goal.super_fold_with(self.as_dyn(), binders)
+    fn fold_goal(&mut self, goal: &Goal<I>, outer_binder: DebruijnIndex) -> Fallible<Goal<TI>> {
+        goal.super_fold_with(self.as_dyn(), outer_binder)
     }
 
     /// If overridden to return true, then folding will panic if a
@@ -122,14 +126,18 @@ where
     ///
     /// This should return a type suitable for a context with
     /// `binders` in scope.
-    fn fold_free_var_ty(&mut self, bound_var: BoundVar, binders: usize) -> Fallible<Ty<TI>> {
+    fn fold_free_var_ty(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Ty<TI>> {
         if self.forbid_free_vars() {
             panic!(
-                "unexpected free variable with depth `{:?}` in {} binders",
-                bound_var, binders
+                "unexpected free variable with depth `{:?}` with outer binder {:?}",
+                bound_var, outer_binder
             )
         } else {
-            let bound_var = bound_var.shifted_in_by(binders);
+            let bound_var = bound_var.shifted_in_from(outer_binder);
             Ok(TyData::<TI>::BoundVar(bound_var).intern(self.target_interner()))
         }
     }
@@ -138,15 +146,15 @@ where
     fn fold_free_var_lifetime(
         &mut self,
         bound_var: BoundVar,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Lifetime<TI>> {
         if self.forbid_free_vars() {
             panic!(
-                "unexpected free variable with depth `{:?}` in {} binders",
-                bound_var, binders
+                "unexpected free variable with depth `{:?}` with outer binder {:?}",
+                bound_var, outer_binder
             )
         } else {
-            let bound_var = bound_var.shifted_in_by(binders);
+            let bound_var = bound_var.shifted_in_from(outer_binder);
             Ok(LifetimeData::<TI>::BoundVar(bound_var).intern(self.target_interner()))
         }
     }
@@ -164,10 +172,11 @@ where
     ///
     /// - `universe` is the universe of the `TypeName::ForAll` that was found
     /// - `binders` is the number of binders in scope
+    #[allow(unused_variables)]
     fn fold_free_placeholder_ty(
         &mut self,
         universe: PlaceholderIndex,
-        _binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Ty<TI>> {
         if self.forbid_free_placeholders() {
             panic!("unexpected placeholder type `{:?}`", universe)
@@ -177,10 +186,11 @@ where
     }
 
     /// As with `fold_free_placeholder_ty`, but for lifetimes.
+    #[allow(unused_variables)]
     fn fold_free_placeholder_lifetime(
         &mut self,
         universe: PlaceholderIndex,
-        _binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Lifetime<TI>> {
         if self.forbid_free_placeholders() {
             panic!("unexpected placeholder lifetime `{:?}`", universe)
@@ -203,7 +213,12 @@ where
     ///
     /// - `universe` is the universe of the `TypeName::ForAll` that was found
     /// - `binders` is the number of binders in scope
-    fn fold_inference_ty(&mut self, var: InferenceVar, _binders: usize) -> Fallible<Ty<TI>> {
+    #[allow(unused_variables)]
+    fn fold_inference_ty(
+        &mut self,
+        var: InferenceVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Ty<TI>> {
         if self.forbid_inference_vars() {
             panic!("unexpected inference type `{:?}`", var)
         } else {
@@ -212,10 +227,11 @@ where
     }
 
     /// As with `fold_free_inference_ty`, but for lifetimes.
+    #[allow(unused_variables)]
     fn fold_inference_lifetime(
         &mut self,
         var: InferenceVar,
-        _binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Lifetime<TI>> {
         if self.forbid_inference_vars() {
             panic!("unexpected inference lifetime `'{:?}`", var)
@@ -260,7 +276,7 @@ pub trait Fold<I: Interner, TI: TargetInterner<I> = I>: Debug {
     fn fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
@@ -274,7 +290,7 @@ pub trait SuperFold<I: Interner, TI: TargetInterner<I> = I>: Fold<I, TI> {
     fn super_fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
@@ -290,13 +306,13 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Ty<I> {
     fn fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
         TI: 'i,
     {
-        folder.fold_ty(self, binders)
+        folder.fold_ty(self, outer_binder)
     }
 }
 
@@ -309,7 +325,7 @@ where
     fn super_fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Ty<TI>>
     where
         I: 'i,
@@ -318,36 +334,29 @@ where
         let interner = folder.interner();
         match self.data(interner) {
             TyData::BoundVar(bound_var) => {
-                if let Some(bound_var1) = bound_var.shifted_out_by(binders) {
+                if let Some(bound_var1) = bound_var.shifted_out_to(outer_binder) {
                     // This variable was bound outside of the binders
                     // that we have traversed during folding;
                     // therefore, it is free. Let the folder have a
                     // crack at it.
-                    folder.fold_free_var_ty(bound_var1, binders)
+                    folder.fold_free_var_ty(bound_var1, outer_binder)
                 } else {
                     // This variable was bound within the binders that
                     // we folded over, so just return a bound
                     // variable.
                     Ok(TyData::<TI>::BoundVar(*bound_var).intern(folder.target_interner()))
                 }
             }
-            TyData::Dyn(clauses) => {
-                Ok(TyData::Dyn(clauses.fold_with(folder, binders)?)
-                    .intern(folder.target_interner()))
-            }
-            TyData::InferenceVar(var) => folder.fold_inference_ty(*var, binders),
-            TyData::Apply(apply) => {
-                Ok(TyData::Apply(apply.fold_with(folder, binders)?)
-                    .intern(folder.target_interner()))
-            }
-            TyData::Placeholder(ui) => Ok(folder.fold_free_placeholder_ty(*ui, binders)?),
-            TyData::Alias(proj) => Ok(
-                TyData::Alias(proj.fold_with(folder, binders)?).intern(folder.target_interner())
-            ),
-            TyData::Function(fun) => {
-                Ok(TyData::Function(fun.fold_with(folder, binders)?)
-                    .intern(folder.target_interner()))
-            }
+            TyData::Dyn(clauses) => Ok(TyData::Dyn(clauses.fold_with(folder, outer_binder)?)
+                .intern(folder.target_interner())),
+            TyData::InferenceVar(var) => folder.fold_inference_ty(*var, outer_binder),
+            TyData::Apply(apply) => Ok(TyData::Apply(apply.fold_with(folder, outer_binder)?)
+                .intern(folder.target_interner())),
+            TyData::Placeholder(ui) => Ok(folder.fold_free_placeholder_ty(*ui, outer_binder)?),
+            TyData::Alias(proj) => Ok(TyData::Alias(proj.fold_with(folder, outer_binder)?)
+                .intern(folder.target_interner())),
+            TyData::Function(fun) => Ok(TyData::Function(fun.fold_with(folder, outer_binder)?)
+                .intern(folder.target_interner())),
         }
     }
 }
@@ -361,13 +370,13 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Lifetime<I> {
     fn fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
         TI: 'i,
     {
-        folder.fold_lifetime(self, binders)
+        folder.fold_lifetime(self, outer_binder)
     }
 }
 
@@ -379,7 +388,7 @@ where
     fn super_fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Lifetime<TI>>
     where
         I: 'i,
@@ -388,22 +397,22 @@ where
         let interner = folder.interner();
         match self.data(interner) {
             LifetimeData::BoundVar(bound_var) => {
-                if let Some(bound_var1) = bound_var.shifted_out_by(binders) {
+                if let Some(bound_var1) = bound_var.shifted_out_to(outer_binder) {
                     // This variable was bound outside of the binders
                     // that we have traversed during folding;
                     // therefore, it is free. Let the folder have a
                     // crack at it.
-                    folder.fold_free_var_lifetime(bound_var1, binders)
+                    folder.fold_free_var_lifetime(bound_var1, outer_binder)
                 } else {
                     // This variable was bound within the binders that
                     // we folded over, so just return a bound
                     // variable.
                     Ok(LifetimeData::<TI>::BoundVar(*bound_var).intern(folder.target_interner()))
                 }
             }
-            LifetimeData::InferenceVar(var) => folder.fold_inference_lifetime(*var, binders),
+            LifetimeData::InferenceVar(var) => folder.fold_inference_lifetime(*var, outer_binder),
             LifetimeData::Placeholder(universe) => {
-                folder.fold_free_placeholder_lifetime(*universe, binders)
+                folder.fold_free_placeholder_lifetime(*universe, outer_binder)
             }
             LifetimeData::Phantom(..) => unreachable!(),
         }
@@ -418,13 +427,13 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Goal<I> {
     fn fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
         TI: 'i,
     {
-        folder.fold_goal(self, binders)
+        folder.fold_goal(self, outer_binder)
     }
 }
 
@@ -433,7 +442,7 @@ impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for Goal<I> {
     fn super_fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
@@ -443,7 +452,7 @@ impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for Goal<I> {
         let target_interner = folder.target_interner();
         Ok(Goal::new(
             target_interner,
-            self.data(interner).fold_with(folder, binders)?,
+            self.data(interner).fold_with(folder, outer_binder)?,
         ))
     }
 }
@@ -457,12 +466,12 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ProgramClause<I> {
     fn fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
-        binders: usize,
+        outer_binder: DebruijnIndex,
     ) -> Fallible<Self::Result>
     where
         I: 'i,
         TI: 'i,
     {
-        folder.fold_program_clause(self, binders)
+        folder.fold_program_clause(self, outer_binder)
     }
 }