From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs | 256 ++++++++++++++++++++++++ 1 file changed, 256 insertions(+) create mode 100644 vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs (limited to 'vendor/chalk-ir-0.80.0/src/fold/boring_impls.rs') 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, I: Interner> Fold for Vec { + type Result = Vec; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + in_place::fallible_map_vec(self, |e| e.fold_with(folder, outer_binder)) + } +} + +impl, I: Interner> Fold for Box { + type Result = Box; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + in_place::fallible_map_box(self, |e| e.fold_with(folder, outer_binder)) + } +} + +macro_rules! tuple_fold { + ($($n:ident),*) => { + impl<$($n: Fold,)* I: Interner> Fold for ($($n,)*) { + type Result = ($($n::Result,)*); + fn fold_with(self, folder: &mut dyn Folder, outer_binder: DebruijnIndex) -> Result + { + #[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, I: Interner> Fold for Option { + type Result = Option; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + match self { + None => Ok(None), + Some(e) => Ok(Some(e.fold_with(folder, outer_binder)?)), + } + } +} + +impl Fold for GenericArg { + type Result = GenericArg; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + let interner = folder.interner(); + + let data = self + .data(interner) + .clone() + .fold_with(folder, outer_binder)?; + Ok(GenericArg::new(interner, data)) + } +} + +impl Fold for Substitution { + type Result = Substitution; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + let interner = folder.interner(); + + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + Substitution::from_fallible(interner, folded) + } +} + +impl Fold for Goals { + type Result = Goals; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + Goals::from_fallible(interner, folded) + } +} + +impl Fold for ProgramClauses { + type Result = ProgramClauses; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + ProgramClauses::from_fallible(interner, folded) + } +} + +impl Fold for QuantifiedWhereClauses { + type Result = QuantifiedWhereClauses; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + let interner = folder.interner(); + let folded = self + .iter(interner) + .cloned() + .map(|p| p.fold_with(folder, outer_binder)); + QuantifiedWhereClauses::from_fallible(interner, folded) + } +} + +impl Fold for Constraints { + type Result = Constraints; + fn fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> Result { + 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 $crate::fold::Fold for $t { + type Result = Self; + fn fold_with( + self, + _folder: &mut dyn ($crate::fold::Folder), + _outer_binder: DebruijnIndex, + ) -> ::std::result::Result { + 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 $crate::fold::Fold for $t { + type Result = $t; + fn fold_with( + self, + _folder: &mut dyn ($crate::fold::Folder), + _outer_binder: DebruijnIndex, + ) -> ::std::result::Result { + 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 SuperFold for ProgramClauseData { + fn super_fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> ::std::result::Result { + Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?)) + } +} + +impl SuperFold for ProgramClause { + fn super_fold_with( + self, + folder: &mut dyn Folder, + outer_binder: DebruijnIndex, + ) -> ::std::result::Result { + let clause = self.data(folder.interner()).clone(); + Ok(clause + .super_fold_with(folder, outer_binder)? + .intern(folder.interner())) + } +} + +impl Fold for PhantomData { + type Result = PhantomData; + + fn fold_with( + self, + _folder: &mut dyn Folder, + _outer_binder: DebruijnIndex, + ) -> ::std::result::Result { + Ok(PhantomData) + } +} -- cgit v1.2.3