diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
commit | 698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch) | |
tree | 173a775858bd501c378080a10dca74132f05bc50 /vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs | |
parent | Initial commit. (diff) | |
download | rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip |
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs')
-rw-r--r-- | vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs | 256 |
1 files changed, 256 insertions, 0 deletions
diff --git a/vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs b/vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs new file mode 100644 index 000000000..9210ecac8 --- /dev/null +++ b/vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs @@ -0,0 +1,256 @@ +//! This module contains "rote and uninteresting" impls of `Fold` for +//! various types. In general, we prefer to derive `Fold`, but +//! sometimes that doesn't work for whatever reason. +//! +//! The more interesting impls of `Fold` remain in the `fold` module. + +use super::in_place; +use crate::*; +use std::marker::PhantomData; + +impl<T: Fold<I>, I: Interner> Fold<I> for Vec<T> { + type Result = Vec<T::Result>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + in_place::fallible_map_vec(self, |e| e.fold_with(folder, outer_binder)) + } +} + +impl<T: Fold<I>, I: Interner> Fold<I> for Box<T> { + type Result = Box<T::Result>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + in_place::fallible_map_box(self, |e| e.fold_with(folder, outer_binder)) + } +} + +macro_rules! tuple_fold { + ($($n:ident),*) => { + impl<$($n: Fold<I>,)* I: Interner> Fold<I> for ($($n,)*) { + type Result = ($($n::Result,)*); + fn fold_with<Error>(self, folder: &mut dyn Folder<I, Error = Error>, outer_binder: DebruijnIndex) -> Result<Self::Result, Error> + { + #[allow(non_snake_case)] + let ($($n),*) = self; + Ok(($($n.fold_with(folder, outer_binder)?,)*)) + } + } + } +} + +tuple_fold!(A, B); +tuple_fold!(A, B, C); +tuple_fold!(A, B, C, D); +tuple_fold!(A, B, C, D, E); + +impl<T: Fold<I>, I: Interner> Fold<I> for Option<T> { + type Result = Option<T::Result>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + match self { + None => Ok(None), + Some(e) => Ok(Some(e.fold_with(folder, outer_binder)?)), + } + } +} + +impl<I: Interner> Fold<I> for GenericArg<I> { + type Result = GenericArg<I>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + let interner = folder.interner(); + + let data = self + .data(interner) + .clone() + .fold_with(folder, outer_binder)?; + Ok(GenericArg::new(interner, data)) + } +} + +impl<I: Interner> Fold<I> for Substitution<I> { + type Result = Substitution<I>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + let interner = folder.interner(); + + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + Substitution::from_fallible(interner, folded) + } +} + +impl<I: Interner> Fold<I> for Goals<I> { + type Result = Goals<I>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + Goals::from_fallible(interner, folded) + } +} + +impl<I: Interner> Fold<I> for ProgramClauses<I> { + type Result = ProgramClauses<I>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + ProgramClauses::from_fallible(interner, folded) + } +} + +impl<I: Interner> Fold<I> for QuantifiedWhereClauses<I> { + type Result = QuantifiedWhereClauses<I>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + QuantifiedWhereClauses::from_fallible(interner, folded) + } +} + +impl<I: Interner> Fold<I> for Constraints<I> { + type Result = Constraints<I>; + fn fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self::Result, E> { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + Constraints::from_fallible(interner, folded) + } +} + +#[doc(hidden)] +#[macro_export] +macro_rules! copy_fold { + ($t:ty) => { + impl<I: Interner> $crate::fold::Fold<I> for $t { + type Result = Self; + fn fold_with<E>( + self, + _folder: &mut dyn ($crate::fold::Folder<I, Error = E>), + _outer_binder: DebruijnIndex, + ) -> ::std::result::Result<Self::Result, E> { + Ok(self) + } + } + }; +} + +copy_fold!(bool); +copy_fold!(usize); +copy_fold!(UniverseIndex); +copy_fold!(PlaceholderIndex); +copy_fold!(QuantifierKind); +copy_fold!(DebruijnIndex); +copy_fold!(()); +copy_fold!(UintTy); +copy_fold!(IntTy); +copy_fold!(FloatTy); +copy_fold!(Scalar); +copy_fold!(ClausePriority); +copy_fold!(Mutability); +copy_fold!(Safety); + +#[doc(hidden)] +#[macro_export] +macro_rules! id_fold { + ($t:ident) => { + impl<I: Interner> $crate::fold::Fold<I> for $t<I> { + type Result = $t<I>; + fn fold_with<E>( + self, + _folder: &mut dyn ($crate::fold::Folder<I, Error = E>), + _outer_binder: DebruijnIndex, + ) -> ::std::result::Result<Self::Result, E> { + Ok(self) + } + } + }; +} + +id_fold!(ImplId); +id_fold!(AdtId); +id_fold!(TraitId); +id_fold!(AssocTypeId); +id_fold!(OpaqueTyId); +id_fold!(FnDefId); +id_fold!(ClosureId); +id_fold!(GeneratorId); +id_fold!(ForeignDefId); + +impl<I: Interner> SuperFold<I> for ProgramClauseData<I> { + fn super_fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> ::std::result::Result<Self::Result, E> { + Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?)) + } +} + +impl<I: Interner> SuperFold<I> for ProgramClause<I> { + fn super_fold_with<E>( + self, + folder: &mut dyn Folder<I, Error = E>, + outer_binder: DebruijnIndex, + ) -> ::std::result::Result<Self::Result, E> { + let clause = self.data(folder.interner()).clone(); + Ok(clause + .super_fold_with(folder, outer_binder)? + .intern(folder.interner())) + } +} + +impl<I: Interner> Fold<I> for PhantomData<I> { + type Result = PhantomData<I>; + + fn fold_with<E>( + self, + _folder: &mut dyn Folder<I, Error = E>, + _outer_binder: DebruijnIndex, + ) -> ::std::result::Result<Self::Result, E> { + Ok(PhantomData) + } +} |