vendor/chalk-ir-0.14.0/src/fold/boring_impls.rs

   1 //! This module contains "rote and uninteresting" impls of `Fold` for
   2 //! various types. In general, we prefer to derive `Fold`, but
   3 //! sometimes that doesn't work for whatever reason.
   4 //!
   5 //! The more interesting impls of `Fold` remain in the `fold` module.
   6
   7 use crate::interner::TargetInterner;
   8 use crate::*;
   9 use std::marker::PhantomData;
  10 use std::sync::Arc;
  11
  12 impl<'a, T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for &'a T {
  13     type Result = T::Result;
  14     fn fold_with<'i>(
  15         &self,
  16         folder: &mut dyn Folder<'i, I, TI>,
  17         outer_binder: DebruijnIndex,
  18     ) -> Fallible<Self::Result>
  19     where
  20         I: 'i,
  21         TI: 'i,
  22     {
  23         (**self).fold_with(folder, outer_binder)
  24     }
  25 }
  26
  27 impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Vec<T> {
  28     type Result = Vec<T::Result>;
  29     fn fold_with<'i>(
  30         &self,
  31         folder: &mut dyn Folder<'i, I, TI>,
  32         outer_binder: DebruijnIndex,
  33     ) -> Fallible<Self::Result>
  34     where
  35         I: 'i,
  36         TI: 'i,
  37     {
  38         self.iter()
  39             .map(|e| e.fold_with(folder, outer_binder))
  40             .collect()
  41     }
  42 }
  43
  44 impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Box<T> {
  45     type Result = Box<T::Result>;
  46     fn fold_with<'i>(
  47         &self,
  48         folder: &mut dyn Folder<'i, I, TI>,
  49         outer_binder: DebruijnIndex,
  50     ) -> Fallible<Self::Result>
  51     where
  52         I: 'i,
  53         TI: 'i,
  54     {
  55         Ok(Box::new((**self).fold_with(folder, outer_binder)?))
  56     }
  57 }
  58
  59 impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Arc<T> {
  60     type Result = Arc<T::Result>;
  61     fn fold_with<'i>(
  62         &self,
  63         folder: &mut dyn Folder<'i, I, TI>,
  64         outer_binder: DebruijnIndex,
  65     ) -> Fallible<Self::Result>
  66     where
  67         I: 'i,
  68         TI: 'i,
  69     {
  70         Ok(Arc::new((**self).fold_with(folder, outer_binder)?))
  71     }
  72 }
  73
  74 macro_rules! tuple_fold {
  75     ($($n:ident),*) => {
  76         impl<$($n: Fold<I, TI>,)* I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ($($n,)*) {
  77             type Result = ($($n::Result,)*);
  78             fn fold_with<'i>(&self, folder: &mut dyn Folder<'i, I, TI>, outer_binder: DebruijnIndex) -> Fallible<Self::Result>
  79             where
  80                 I: 'i,
  81                 TI: 'i,
  82             {
  83                 #[allow(non_snake_case)]
  84                 let &($(ref $n),*) = self;
  85                 Ok(($($n.fold_with(folder, outer_binder)?,)*))
  86             }
  87         }
  88     }
  89 }
  90
  91 tuple_fold!(A, B);
  92 tuple_fold!(A, B, C);
  93 tuple_fold!(A, B, C, D);
  94 tuple_fold!(A, B, C, D, E);
  95
  96 impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Option<T> {
  97     type Result = Option<T::Result>;
  98     fn fold_with<'i>(
  99         &self,
 100         folder: &mut dyn Folder<'i, I, TI>,
 101         outer_binder: DebruijnIndex,
 102     ) -> Fallible<Self::Result>
 103     where
 104         I: 'i,
 105         TI: 'i,
 106     {
 107         match self {
 108             None => Ok(None),
 109             Some(e) => Ok(Some(e.fold_with(folder, outer_binder)?)),
 110         }
 111     }
 112 }
 113
 114 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for GenericArg<I> {
 115     type Result = GenericArg<TI>;
 116     fn fold_with<'i>(
 117         &self,
 118         folder: &mut dyn Folder<'i, I, TI>,
 119         outer_binder: DebruijnIndex,
 120     ) -> Fallible<Self::Result>
 121     where
 122         I: 'i,
 123         TI: 'i,
 124     {
 125         let interner = folder.interner();
 126         let target_interner = folder.target_interner();
 127
 128         let data = self.data(interner).fold_with(folder, outer_binder)?;
 129         Ok(GenericArg::new(target_interner, data))
 130     }
 131 }
 132
 133 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Substitution<I> {
 134     type Result = Substitution<TI>;
 135     fn fold_with<'i>(
 136         &self,
 137         folder: &mut dyn Folder<'i, I, TI>,
 138         outer_binder: DebruijnIndex,
 139     ) -> Fallible<Self::Result>
 140     where
 141         I: 'i,
 142         TI: 'i,
 143     {
 144         let interner = folder.interner();
 145         let target_interner = folder.target_interner();
 146         let folded = self
 147             .iter(interner)
 148             .map(|p| p.fold_with(folder, outer_binder));
 149         Ok(Substitution::from_fallible(target_interner, folded)?)
 150     }
 151 }
 152
 153 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Goals<I> {
 154     type Result = Goals<TI>;
 155     fn fold_with<'i>(
 156         &self,
 157         folder: &mut dyn Folder<'i, I, TI>,
 158         outer_binder: DebruijnIndex,
 159     ) -> Fallible<Self::Result>
 160     where
 161         I: 'i,
 162         TI: 'i,
 163     {
 164         let interner = folder.interner();
 165         let target_interner = folder.target_interner();
 166         let folded = self
 167             .iter(interner)
 168             .map(|p| p.fold_with(folder, outer_binder));
 169         Ok(Goals::from_fallible(target_interner, folded)?)
 170     }
 171 }
 172
 173 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ProgramClauses<I> {
 174     type Result = ProgramClauses<TI>;
 175     fn fold_with<'i>(
 176         &self,
 177         folder: &mut dyn Folder<'i, I, TI>,
 178         outer_binder: DebruijnIndex,
 179     ) -> Fallible<Self::Result>
 180     where
 181         I: 'i,
 182         TI: 'i,
 183     {
 184         let interner = folder.interner();
 185         let target_interner = folder.target_interner();
 186         let folded = self
 187             .iter(interner)
 188             .map(|p| p.fold_with(folder, outer_binder));
 189         Ok(ProgramClauses::from_fallible(target_interner, folded)?)
 190     }
 191 }
 192
 193 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for QuantifiedWhereClauses<I> {
 194     type Result = QuantifiedWhereClauses<TI>;
 195     fn fold_with<'i>(
 196         &self,
 197         folder: &mut dyn Folder<'i, I, TI>,
 198         outer_binder: DebruijnIndex,
 199     ) -> Fallible<Self::Result>
 200     where
 201         I: 'i,
 202         TI: 'i,
 203     {
 204         let interner = folder.interner();
 205         let target_interner = folder.target_interner();
 206         let folded = self
 207             .iter(interner)
 208             .map(|p| p.fold_with(folder, outer_binder));
 209         Ok(QuantifiedWhereClauses::from_fallible(
 210             target_interner,
 211             folded,
 212         )?)
 213     }
 214 }
 215
 216 #[macro_export]
 217 macro_rules! copy_fold {
 218     ($t:ty) => {
 219         impl<I: Interner, TI: TargetInterner<I>> $crate::fold::Fold<I, TI> for $t {
 220             type Result = Self;
 221             fn fold_with<'i>(
 222                 &self,
 223                 _folder: &mut dyn ($crate::fold::Folder<'i, I, TI>),
 224                 _outer_binder: DebruijnIndex,
 225             ) -> ::chalk_ir::Fallible<Self::Result>
 226             where
 227                 I: 'i,
 228                 TI: 'i,
 229             {
 230                 Ok(*self)
 231             }
 232         }
 233     };
 234 }
 235
 236 copy_fold!(bool);
 237 copy_fold!(usize);
 238 copy_fold!(UniverseIndex);
 239 copy_fold!(PlaceholderIndex);
 240 copy_fold!(QuantifierKind);
 241 copy_fold!(DebruijnIndex);
 242 copy_fold!(());
 243 copy_fold!(UintTy);
 244 copy_fold!(IntTy);
 245 copy_fold!(FloatTy);
 246 copy_fold!(Scalar);
 247 copy_fold!(ClausePriority);
 248 copy_fold!(Mutability);
 249
 250 #[macro_export]
 251 macro_rules! id_fold {
 252     ($t:ident) => {
 253         $crate::id_fold!($t, transfer_def_id);
 254     };
 255
 256     ($t:ident, $transfer_fn:ident) => {
 257         impl<I: Interner, TI: TargetInterner<I>> $crate::fold::Fold<I, TI> for $t<I> {
 258             type Result = $t<TI>;
 259             fn fold_with<'i>(
 260                 &self,
 261                 _folder: &mut dyn ($crate::fold::Folder<'i, I, TI>),
 262                 _outer_binder: DebruijnIndex,
 263             ) -> ::chalk_ir::Fallible<Self::Result>
 264             where
 265                 I: 'i,
 266                 TI: 'i,
 267             {
 268                 let $t(def_id_tf) = *self;
 269                 let def_id_ttf = TI::$transfer_fn(def_id_tf);
 270                 Ok($t(def_id_ttf))
 271             }
 272         }
 273     };
 274 }
 275
 276 id_fold!(ImplId);
 277 id_fold!(AdtId, transfer_adt_id);
 278 id_fold!(TraitId);
 279 id_fold!(AssocTypeId);
 280 id_fold!(OpaqueTyId);
 281 id_fold!(FnDefId);
 282 id_fold!(ClosureId);
 283
 284 impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<I> {
 285     fn super_fold_with<'i>(
 286         &self,
 287         folder: &mut dyn Folder<'i, I, TI>,
 288         outer_binder: DebruijnIndex,
 289     ) -> ::chalk_ir::Fallible<Self::Result>
 290     where
 291         I: 'i,
 292         TI: 'i,
 293     {
 294         Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?))
 295     }
 296 }
 297
 298 impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
 299     fn super_fold_with<'i>(
 300         &self,
 301         folder: &mut dyn Folder<'i, I, TI>,
 302         outer_binder: DebruijnIndex,
 303     ) -> ::chalk_ir::Fallible<Self::Result>
 304     where
 305         I: 'i,
 306         TI: 'i,
 307     {
 308         let clause = self.data(folder.interner());
 309         Ok(clause
 310             .super_fold_with(folder, outer_binder)?
 311             .intern(folder.target_interner()))
 312     }
 313 }
 314
 315 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I> {
 316     type Result = PhantomData<TI>;
 317
 318     fn fold_with<'i>(
 319         &self,
 320         _folder: &mut dyn Folder<'i, I, TI>,
 321         _outer_binder: DebruijnIndex,
 322     ) -> ::chalk_ir::Fallible<Self::Result>
 323     where
 324         I: 'i,
 325         TI: 'i,
 326     {
 327         Ok(PhantomData)
 328     }
 329 }