vendor/chalk-ir-0.55.0/src/fold/binder_impls.rs

   1 //! This module contains impls of `Fold` for those types that
   2 //! introduce binders.
   3 //!
   4 //! The more interesting impls of `Fold` remain in the `fold` module.
   5
   6 use crate::*;
   7
   8 impl<I: Interner> Fold<I> for FnPointer<I> {
   9     type Result = FnPointer<I>;
  10     fn fold_with<'i>(
  11         self,
  12         folder: &mut dyn Folder<'i, I>,
  13         outer_binder: DebruijnIndex,
  14     ) -> Fallible<Self::Result>
  15     where
  16         I: 'i,
  17     {
  18         let FnPointer {
  19             num_binders,
  20             substitution,
  21             sig,
  22         } = self;
  23         Ok(FnPointer {
  24             num_binders,
  25             substitution: substitution.fold_with(folder, outer_binder.shifted_in())?,
  26             sig: FnSig {
  27                 abi: sig.abi,
  28                 safety: sig.safety,
  29                 variadic: sig.variadic,
  30             },
  31         })
  32     }
  33 }
  34
  35 impl<T, I: Interner> Fold<I> for Binders<T>
  36 where
  37     T: HasInterner<Interner = I> + Fold<I>,
  38     <T as Fold<I>>::Result: HasInterner<Interner = I>,
  39     I: Interner,
  40 {
  41     type Result = Binders<T::Result>;
  42     fn fold_with<'i>(
  43         self,
  44         folder: &mut dyn Folder<'i, I>,
  45         outer_binder: DebruijnIndex,
  46     ) -> Fallible<Self::Result>
  47     where
  48         I: 'i,
  49     {
  50         let Binders {
  51             binders: self_binders,
  52             value: self_value,
  53         } = self;
  54         let value = self_value.fold_with(folder, outer_binder.shifted_in())?;
  55         let binders = VariableKinds {
  56             interned: self_binders.interned().clone(),
  57         };
  58         Ok(Binders::new(binders, value))
  59     }
  60 }
  61
  62 impl<I, T> Fold<I> for Canonical<T>
  63 where
  64     I: Interner,
  65     T: HasInterner<Interner = I> + Fold<I>,
  66     <T as Fold<I>>::Result: HasInterner<Interner = I>,
  67 {
  68     type Result = Canonical<T::Result>;
  69     fn fold_with<'i>(
  70         self,
  71         folder: &mut dyn Folder<'i, I>,
  72         outer_binder: DebruijnIndex,
  73     ) -> Fallible<Self::Result>
  74     where
  75         I: 'i,
  76     {
  77         let Canonical {
  78             binders: self_binders,
  79             value: self_value,
  80         } = self;
  81         let value = self_value.fold_with(folder, outer_binder.shifted_in())?;
  82         let binders = CanonicalVarKinds {
  83             interned: self_binders.interned().clone(),
  84         };
  85         Ok(Canonical { binders, value })
  86     }
  87 }