vendor/chalk-ir-0.80.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 super::in_place;
   8 use crate::*;
   9 use std::marker::PhantomData;
  10
  11 impl<T: Fold<I>, I: Interner> Fold<I> for Vec<T> {
  12     type Result = Vec<T::Result>;
  13     fn fold_with<E>(
  14         self,
  15         folder: &mut dyn Folder<I, Error = E>,
  16         outer_binder: DebruijnIndex,
  17     ) -> Result<Self::Result, E> {
  18         in_place::fallible_map_vec(self, |e| e.fold_with(folder, outer_binder))
  19     }
  20 }
  21
  22 impl<T: Fold<I>, I: Interner> Fold<I> for Box<T> {
  23     type Result = Box<T::Result>;
  24     fn fold_with<E>(
  25         self,
  26         folder: &mut dyn Folder<I, Error = E>,
  27         outer_binder: DebruijnIndex,
  28     ) -> Result<Self::Result, E> {
  29         in_place::fallible_map_box(self, |e| e.fold_with(folder, outer_binder))
  30     }
  31 }
  32
  33 macro_rules! tuple_fold {
  34     ($($n:ident),*) => {
  35         impl<$($n: Fold<I>,)* I: Interner> Fold<I> for ($($n,)*) {
  36             type Result = ($($n::Result,)*);
  37             fn fold_with<Error>(self, folder: &mut dyn Folder<I, Error = Error>, outer_binder: DebruijnIndex) -> Result<Self::Result, Error>
  38             {
  39                 #[allow(non_snake_case)]
  40                 let ($($n),*) = self;
  41                 Ok(($($n.fold_with(folder, outer_binder)?,)*))
  42             }
  43         }
  44     }
  45 }
  46
  47 tuple_fold!(A, B);
  48 tuple_fold!(A, B, C);
  49 tuple_fold!(A, B, C, D);
  50 tuple_fold!(A, B, C, D, E);
  51
  52 impl<T: Fold<I>, I: Interner> Fold<I> for Option<T> {
  53     type Result = Option<T::Result>;
  54     fn fold_with<E>(
  55         self,
  56         folder: &mut dyn Folder<I, Error = E>,
  57         outer_binder: DebruijnIndex,
  58     ) -> Result<Self::Result, E> {
  59         match self {
  60             None => Ok(None),
  61             Some(e) => Ok(Some(e.fold_with(folder, outer_binder)?)),
  62         }
  63     }
  64 }
  65
  66 impl<I: Interner> Fold<I> for GenericArg<I> {
  67     type Result = GenericArg<I>;
  68     fn fold_with<E>(
  69         self,
  70         folder: &mut dyn Folder<I, Error = E>,
  71         outer_binder: DebruijnIndex,
  72     ) -> Result<Self::Result, E> {
  73         let interner = folder.interner();
  74
  75         let data = self
  76             .data(interner)
  77             .clone()
  78             .fold_with(folder, outer_binder)?;
  79         Ok(GenericArg::new(interner, data))
  80     }
  81 }
  82
  83 impl<I: Interner> Fold<I> for Substitution<I> {
  84     type Result = Substitution<I>;
  85     fn fold_with<E>(
  86         self,
  87         folder: &mut dyn Folder<I, Error = E>,
  88         outer_binder: DebruijnIndex,
  89     ) -> Result<Self::Result, E> {
  90         let interner = folder.interner();
  91
  92         let folded = self
  93             .iter(interner)
  94             .cloned()
  95             .map(|p| p.fold_with(folder, outer_binder));
  96         Substitution::from_fallible(interner, folded)
  97     }
  98 }
  99
 100 impl<I: Interner> Fold<I> for Goals<I> {
 101     type Result = Goals<I>;
 102     fn fold_with<E>(
 103         self,
 104         folder: &mut dyn Folder<I, Error = E>,
 105         outer_binder: DebruijnIndex,
 106     ) -> Result<Self::Result, E> {
 107         let interner = folder.interner();
 108         let folded = self
 109             .iter(interner)
 110             .cloned()
 111             .map(|p| p.fold_with(folder, outer_binder));
 112         Goals::from_fallible(interner, folded)
 113     }
 114 }
 115
 116 impl<I: Interner> Fold<I> for ProgramClauses<I> {
 117     type Result = ProgramClauses<I>;
 118     fn fold_with<E>(
 119         self,
 120         folder: &mut dyn Folder<I, Error = E>,
 121         outer_binder: DebruijnIndex,
 122     ) -> Result<Self::Result, E> {
 123         let interner = folder.interner();
 124         let folded = self
 125             .iter(interner)
 126             .cloned()
 127             .map(|p| p.fold_with(folder, outer_binder));
 128         ProgramClauses::from_fallible(interner, folded)
 129     }
 130 }
 131
 132 impl<I: Interner> Fold<I> for QuantifiedWhereClauses<I> {
 133     type Result = QuantifiedWhereClauses<I>;
 134     fn fold_with<E>(
 135         self,
 136         folder: &mut dyn Folder<I, Error = E>,
 137         outer_binder: DebruijnIndex,
 138     ) -> Result<Self::Result, E> {
 139         let interner = folder.interner();
 140         let folded = self
 141             .iter(interner)
 142             .cloned()
 143             .map(|p| p.fold_with(folder, outer_binder));
 144         QuantifiedWhereClauses::from_fallible(interner, folded)
 145     }
 146 }
 147
 148 impl<I: Interner> Fold<I> for Constraints<I> {
 149     type Result = Constraints<I>;
 150     fn fold_with<E>(
 151         self,
 152         folder: &mut dyn Folder<I, Error = E>,
 153         outer_binder: DebruijnIndex,
 154     ) -> Result<Self::Result, E> {
 155         let interner = folder.interner();
 156         let folded = self
 157             .iter(interner)
 158             .cloned()
 159             .map(|p| p.fold_with(folder, outer_binder));
 160         Constraints::from_fallible(interner, folded)
 161     }
 162 }
 163
 164 #[doc(hidden)]
 165 #[macro_export]
 166 macro_rules! copy_fold {
 167     ($t:ty) => {
 168         impl<I: Interner> $crate::fold::Fold<I> for $t {
 169             type Result = Self;
 170             fn fold_with<E>(
 171                 self,
 172                 _folder: &mut dyn ($crate::fold::Folder<I, Error = E>),
 173                 _outer_binder: DebruijnIndex,
 174             ) -> ::std::result::Result<Self::Result, E> {
 175                 Ok(self)
 176             }
 177         }
 178     };
 179 }
 180
 181 copy_fold!(bool);
 182 copy_fold!(usize);
 183 copy_fold!(UniverseIndex);
 184 copy_fold!(PlaceholderIndex);
 185 copy_fold!(QuantifierKind);
 186 copy_fold!(DebruijnIndex);
 187 copy_fold!(());
 188 copy_fold!(UintTy);
 189 copy_fold!(IntTy);
 190 copy_fold!(FloatTy);
 191 copy_fold!(Scalar);
 192 copy_fold!(ClausePriority);
 193 copy_fold!(Mutability);
 194 copy_fold!(Safety);
 195
 196 #[doc(hidden)]
 197 #[macro_export]
 198 macro_rules! id_fold {
 199     ($t:ident) => {
 200         impl<I: Interner> $crate::fold::Fold<I> for $t<I> {
 201             type Result = $t<I>;
 202             fn fold_with<E>(
 203                 self,
 204                 _folder: &mut dyn ($crate::fold::Folder<I, Error = E>),
 205                 _outer_binder: DebruijnIndex,
 206             ) -> ::std::result::Result<Self::Result, E> {
 207                 Ok(self)
 208             }
 209         }
 210     };
 211 }
 212
 213 id_fold!(ImplId);
 214 id_fold!(AdtId);
 215 id_fold!(TraitId);
 216 id_fold!(AssocTypeId);
 217 id_fold!(OpaqueTyId);
 218 id_fold!(FnDefId);
 219 id_fold!(ClosureId);
 220 id_fold!(GeneratorId);
 221 id_fold!(ForeignDefId);
 222
 223 impl<I: Interner> SuperFold<I> for ProgramClauseData<I> {
 224     fn super_fold_with<E>(
 225         self,
 226         folder: &mut dyn Folder<I, Error = E>,
 227         outer_binder: DebruijnIndex,
 228     ) -> ::std::result::Result<Self::Result, E> {
 229         Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?))
 230     }
 231 }
 232
 233 impl<I: Interner> SuperFold<I> for ProgramClause<I> {
 234     fn super_fold_with<E>(
 235         self,
 236         folder: &mut dyn Folder<I, Error = E>,
 237         outer_binder: DebruijnIndex,
 238     ) -> ::std::result::Result<Self::Result, E> {
 239         let clause = self.data(folder.interner()).clone();
 240         Ok(clause
 241             .super_fold_with(folder, outer_binder)?
 242             .intern(folder.interner()))
 243     }
 244 }
 245
 246 impl<I: Interner> Fold<I> for PhantomData<I> {
 247     type Result = PhantomData<I>;
 248
 249     fn fold_with<E>(
 250         self,
 251         _folder: &mut dyn Folder<I, Error = E>,
 252         _outer_binder: DebruijnIndex,
 253     ) -> ::std::result::Result<Self::Result, E> {
 254         Ok(PhantomData)
 255     }
 256 }