vendor/chalk-ir/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::interner::TargetInterner;
   7 use crate::*;
   8
   9 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for FnPointer<I> {
  10     type Result = FnPointer<TI>;
  11     fn fold_with<'i>(
  12         &self,
  13         folder: &mut dyn Folder<'i, I, TI>,
  14         outer_binder: DebruijnIndex,
  15     ) -> Fallible<Self::Result>
  16     where
  17         I: 'i,
  18         TI: 'i,
  19     {
  20         let FnPointer {
  21             num_binders,
  22             substitution,
  23             sig,
  24         } = self;
  25         Ok(FnPointer {
  26             num_binders: *num_binders,
  27             substitution: substitution.fold_with(folder, outer_binder.shifted_in())?,
  28             sig: FnSig {
  29                 abi: TI::transfer_abi(sig.abi),
  30                 safety: sig.safety,
  31                 variadic: sig.variadic,
  32             },
  33         })
  34     }
  35 }
  36
  37 impl<T, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Binders<T>
  38 where
  39     T: HasInterner<Interner = I> + Fold<I, TI>,
  40     <T as Fold<I, TI>>::Result: HasInterner<Interner = TI>,
  41     I: Interner,
  42 {
  43     type Result = Binders<T::Result>;
  44     fn fold_with<'i>(
  45         &self,
  46         folder: &mut dyn Folder<'i, I, TI>,
  47         outer_binder: DebruijnIndex,
  48     ) -> Fallible<Self::Result>
  49     where
  50         I: 'i,
  51         TI: 'i,
  52     {
  53         let Binders {
  54             binders: self_binders,
  55             value: self_value,
  56         } = self;
  57         let value = self_value.fold_with(folder, outer_binder.shifted_in())?;
  58         let binders = VariableKinds {
  59             interned: TI::transfer_variable_kinds(self_binders.interned().clone()),
  60         };
  61         Ok(Binders::new(binders, value))
  62     }
  63 }
  64
  65 impl<I, T, TI> Fold<I, TI> for Canonical<T>
  66 where
  67     I: Interner,
  68     T: HasInterner<Interner = I> + Fold<I, TI>,
  69     <T as Fold<I, TI>>::Result: HasInterner<Interner = TI>,
  70     TI: TargetInterner<I>,
  71 {
  72     type Result = Canonical<T::Result>;
  73     fn fold_with<'i>(
  74         &self,
  75         folder: &mut dyn Folder<'i, I, TI>,
  76         outer_binder: DebruijnIndex,
  77     ) -> Fallible<Self::Result>
  78     where
  79         I: 'i,
  80         TI: 'i,
  81     {
  82         let Canonical {
  83             binders: self_binders,
  84             value: self_value,
  85         } = self;
  86         let value = self_value.fold_with(folder, outer_binder.shifted_in())?;
  87         let binders = CanonicalVarKinds {
  88             interned: TI::transfer_canonical_var_kinds(self_binders.interned().clone()),
  89         };
  90         Ok(Canonical { binders, value })
  91     }
  92 }