distinguish shifting one level from N levels

The new convention is:

* `shift_in` and `shifted_in` assume one level
* `shifted_in_by(N)` to shift by N levels

`shift_out` is analogous but it also always
returns `Option` instead of having an
assert.

Author: nikomatsakis

chalk-integration/src/lowering.rs

@@ -146,7 +146,7 @@ impl<'k> Env<'k> {
         let parameter_map: ParameterMap = self
             .parameter_map
             .iter()
-            .map(|(&k, &v)| (k, v.shifted_in(1)))
+            .map(|(&k, &v)| (k, v.shifted_in()))
             .chain(binders)
             .collect();
         if parameter_map.len() != self.parameter_map.len() + len {

chalk-ir/src/fold.rs

@@ -129,7 +129,7 @@ where
                 bound_var, binders
             )
         } else {
-            let bound_var = bound_var.shifted_in(binders);
+            let bound_var = bound_var.shifted_in_by(binders);
             Ok(TyData::<TI>::BoundVar(bound_var).intern(self.target_interner()))
         }
     }
@@ -146,7 +146,7 @@ where
                 bound_var, binders
             )
         } else {
-            let bound_var = bound_var.shifted_in(binders);
+            let bound_var = bound_var.shifted_in_by(binders);
             Ok(LifetimeData::<TI>::BoundVar(bound_var).intern(self.target_interner()))
         }
     }
@@ -318,7 +318,7 @@ where
         let interner = folder.interner();
         match self.data(interner) {
             TyData::BoundVar(bound_var) => {
-                if let Some(bound_var1) = bound_var.checked_shifted_out(binders) {
+                if let Some(bound_var1) = bound_var.shifted_out_by(binders) {
                     // This variable was bound outside of the binders
                     // that we have traversed during folding;
                     // therefore, it is free. Let the folder have a
@@ -388,7 +388,7 @@ where
         let interner = folder.interner();
         match self.data(interner) {
             LifetimeData::BoundVar(bound_var) => {
-                if let Some(bound_var1) = bound_var.checked_shifted_out(binders) {
+                if let Some(bound_var1) = bound_var.shifted_out_by(binders) {
                     // This variable was bound outside of the binders
                     // that we have traversed during folding;
                     // therefore, it is free. Let the folder have a

chalk-ir/src/fold/shift.rs

@@ -93,7 +93,7 @@ impl<I> Shifter<'_, I> {
     /// + self.adjustment`, and then wraps *that* within the internal
     /// set `binders`.
     fn adjust(&self, bound_var: BoundVar, binders: usize) -> BoundVar {
-        bound_var.shifted_in(self.adjustment + binders)
+        bound_var.shifted_in_by(self.adjustment + binders)
     }
 }
 
@@ -143,8 +143,8 @@ impl<I> DownShifter<'_, I> {
     /// this will fail with `Err`. Otherwise, returns the variable at
     /// this new depth (but adjusted to appear within `binders`).
     fn adjust(&self, bound_var: BoundVar, binders: usize) -> Fallible<BoundVar> {
-        match bound_var.checked_shifted_out(self.adjustment) {
-            Some(bound_var1) => Ok(bound_var1.shifted_in(binders)),
+        match bound_var.shifted_out_by(self.adjustment) {
+            Some(bound_var1) => Ok(bound_var1.shifted_in_by(binders)),
             None => Err(NoSolution),
         }
     }

chalk-ir/src/fold/subst.rs

@@ -55,8 +55,9 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> {
             }
         } else {
             Ok(bound_var
-                .shifted_out(1)
-                .shifted_in(binders)
+                .shifted_out()
+                .expect("cannot fail because this is not the innermost")
+                .shifted_in_by(binders)
                 .to_ty(self.interner()))
         }
     }
@@ -75,8 +76,9 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> {
             }
         } else {
             Ok(bound_var
-                .shifted_out(1)
-                .shifted_in(binders)
+                .shifted_out()
+                .unwrap()
+                .shifted_in_by(binders)
                 .to_lifetime(self.interner()))
         }
     }

chalk-ir/src/lib.rs

@@ -315,21 +315,30 @@ impl BoundVar {
 
     /// Adjusts the debruijn index (see [`DebruijnIndex::shifted_in`]).
     #[must_use]
-    pub fn shifted_in(self, amount: usize) -> Self {
-        BoundVar::new(self.debruijn.shifted_in(amount), self.index)
+    pub fn shifted_in(self) -> Self {
+        BoundVar::new(self.debruijn.shifted_in(), self.index)
     }
 
-    /// Adjusts the debruijn index (see [`DebruijnIndex::shifted_out`]).
+    /// Adjusts the debruijn index (see [`DebruijnIndex::shifted_in`]).
     #[must_use]
-    pub fn shifted_out(self, amount: usize) -> Self {
-        BoundVar::new(self.debruijn.shifted_out(amount), self.index)
+    pub fn shifted_in_by(self, amount: usize) -> Self {
+        BoundVar::new(self.debruijn.shifted_in_by(amount), self.index)
     }
 
-    /// Shift out this variable by `amount` binders, returning `None`
-    /// if not enclosed in that many levels of binders.
-    pub fn checked_shifted_out(self, amount: usize) -> Option<Self> {
-        let debruijn = self.debruijn.checked_shifted_out(amount)?;
-        Some(BoundVar::new(debruijn, self.index))
+    /// Adjusts the debruijn index (see [`DebruijnIndex::shifted_in`]).
+    #[must_use]
+    pub fn shifted_out(self) -> Option<Self> {
+        self.debruijn
+            .shifted_out()
+            .map(|db| BoundVar::new(db, self.index))
+    }
+
+    /// Adjusts the debruijn index (see [`DebruijnIndex::shifted_in`]).
+    #[must_use]
+    pub fn shifted_out_by(self, amount: usize) -> Option<Self> {
+        self.debruijn
+            .shifted_out_by(amount)
+            .map(|db| BoundVar::new(db, self.index))
     }
 
     /// Return the index of the bound variable, but only if it is bound
@@ -435,6 +444,19 @@ impl DebruijnIndex {
         self < binder
     }
 
+    /// Returns the resulting index when this value is moved into
+    /// through one binder.
+    #[must_use]
+    pub fn shifted_in(self) -> DebruijnIndex {
+        self.shifted_in_by(1)
+    }
+
+    /// Update this index in place by shifting it "in" through
+    /// `amount` number of binders.
+    pub fn shift_in(&mut self) {
+        *self = self.shifted_in();
+    }
+
     /// Returns the resulting index when this value is moved into
     /// `amount` number of new binders. So, e.g., if you had
     ///
@@ -446,38 +468,33 @@ impl DebruijnIndex {
     ///
     /// you would need to shift the index for `'a` into a new binder.
     #[must_use]
-    pub fn shifted_in(self, amount: usize) -> DebruijnIndex {
+    pub fn shifted_in_by(self, amount: usize) -> DebruijnIndex {
         DebruijnIndex::from(self.as_usize() + amount)
     }
 
-    /// Update this index in place by shifting it "in" through
-    /// `amount` number of binders.
-    pub fn shift_in(&mut self, amount: usize) {
-        *self = self.shifted_in(amount);
-    }
-
     /// Returns the resulting index when this value is moved out from
     /// `amount` number of new binders.
     #[must_use]
-    pub fn shifted_out(self, amount: usize) -> DebruijnIndex {
-        assert!(self.as_usize() >= amount);
-        DebruijnIndex::from(self.as_usize() - amount)
+    pub fn shifted_out(self) -> Option<DebruijnIndex> {
+        self.shifted_out_by(1)
     }
 
+    /// Update in place by shifting out from `amount` binders.
+    pub fn shift_out(&mut self) {
+        *self = self.shifted_out().unwrap();
+    }
+
+    /// Returns the resulting index when this value is moved out from
+    /// `amount` number of new binders.
     #[must_use]
-    pub fn checked_shifted_out(self, amount: usize) -> Option<DebruijnIndex> {
+    pub fn shifted_out_by(self, amount: usize) -> Option<DebruijnIndex> {
         if self.within(amount) {
             None
         } else {
-            Some(self.shifted_out(amount))
+            Some(DebruijnIndex::from(self.as_usize() - amount))
         }
     }
 
-    /// Update in place by shifting out from `amount` binders.
-    pub fn shift_out(&mut self, amount: usize) {
-        *self = self.shifted_out(amount);
-    }
-
     /// Adjusts any De Bruijn indices so as to make `to_binder` the
     /// innermost binder. That is, if we have something bound at `to_binder`,
     /// it will now be bound at INNERMOST. This is an appropriate thing to do
@@ -498,8 +515,8 @@ impl DebruijnIndex {
     /// If we invoke `shift_out_to_binder` and the region is in fact
     /// bound by one of the binders we are shifting out of, that is an
     /// error (and should fail an assertion failure).
-    pub fn shifted_out_to_binder(self, to_binder: DebruijnIndex) -> Self {
-        self.shifted_out(to_binder.as_usize() - Self::INNERMOST.as_usize())
+    pub fn shifted_out_to_binder(self, to_binder: DebruijnIndex) -> Option<Self> {
+        self.shifted_out_by(to_binder.as_usize() - Self::INNERMOST.as_usize())
     }
 }
 

chalk-ir/src/macros.rs

@@ -35,7 +35,7 @@ macro_rules! ty {
     };
 
     (bound $d:tt $b:tt) => {
-        $crate::TyData::BoundVar($crate::BoundVar::new($crate::DebruijnIndex::INNERMOST.shifted_in($d), $b)).intern(&chalk_ir::interner::ChalkIr)
+        $crate::TyData::BoundVar($crate::BoundVar::new($crate::DebruijnIndex::INNERMOST.shifted_in_by($d), $b)).intern(&chalk_ir::interner::ChalkIr)
     };
 
     (bound $b:expr) => {
@@ -75,7 +75,7 @@ macro_rules! lifetime {
     };
 
     (bound $d:tt $b:tt) => {
-        $crate::LifetimeData::BoundVar($crate::BoundVar::new($crate::DebruijnIndex::INNERMOST.shifted_in($d), $b)).intern(&chalk_ir::interner::ChalkIr)
+        $crate::LifetimeData::BoundVar($crate::BoundVar::new($crate::DebruijnIndex::INNERMOST.shifted_in_by($d), $b)).intern(&chalk_ir::interner::ChalkIr)
     };
 
     (bound $b:expr) => {

chalk-solve/src/infer/canonicalize.rs

@@ -145,7 +145,7 @@ where
                 let free_var = ParameterKind::Ty(self.table.unify.find(var));
                 let bound_var = BoundVar::new(DebruijnIndex::INNERMOST, self.add(free_var));
                 debug!("not yet unified: position={:?}", bound_var);
-                Ok(TyData::BoundVar(bound_var.shifted_in(binders)).intern(interner))
+                Ok(TyData::BoundVar(bound_var.shifted_in_by(binders)).intern(interner))
             }
         }
     }
@@ -171,7 +171,7 @@ where
                 let free_var = ParameterKind::Lifetime(self.table.unify.find(var));
                 let bound_var = BoundVar::new(DebruijnIndex::INNERMOST, self.add(free_var));
                 debug!("not yet unified: position={:?}", bound_var);
-                Ok(LifetimeData::BoundVar(bound_var.shifted_in(binders)).intern(interner))
+                Ok(LifetimeData::BoundVar(bound_var.shifted_in_by(binders)).intern(interner))
             }
         }
     }

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

@@ -417,9 +417,9 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
             }
 
             (TyData::Function(answer), TyData::Function(pending)) => {
-                self.outer_binder.shift_in(1);
+                self.outer_binder.shift_in();
                 Zip::zip_with(self, &answer.parameters, &pending.parameters)?;
-                self.outer_binder.shift_out(1);
+                self.outer_binder.shift_out();
                 Ok(())
             }
 
@@ -484,9 +484,9 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
     where
         T: Zip<I> + Fold<I, Result = T>,
     {
-        self.outer_binder.shift_in(1);
+        self.outer_binder.shift_in();
         Zip::zip_with(self, &answer.value, &pending.value)?;
-        self.outer_binder.shift_out(1);
+        self.outer_binder.shift_out();
         Ok(())
     }
 

chalk-solve/src/wf.rs

@@ -378,7 +378,7 @@ where
                 .iter()
                 .zip(0..)
                 .map(|p| p.to_parameter(interner));
-            let impl_debruin = DebruijnIndex::INNERMOST.shifted_in(1);
+            let impl_debruin = DebruijnIndex::INNERMOST.shifted_in();
             let impl_parameters = impl_binders
                 .iter()
                 .zip(0..)