[rustc.git] / vendor / chalk-ir-0.25.0 / src / fold / boring_impls.rs

//! 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 crate::interner::TargetInterner;
use crate::*;
use std::marker::PhantomData;
use std::sync::Arc;

impl<'a, T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for &'a T {
    type Result = T::Result;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        (**self).fold_with(folder, outer_binder)
    }
}

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Vec<T> {
    type Result = Vec<T::Result>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        self.iter()
            .map(|e| e.fold_with(folder, outer_binder))
            .collect()
    }
}

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Box<T> {
    type Result = Box<T::Result>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        Ok(Box::new((**self).fold_with(folder, outer_binder)?))
    }
}

impl<T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Arc<T> {
    type Result = Arc<T::Result>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        Ok(Arc::new((**self).fold_with(folder, outer_binder)?))
    }
}

macro_rules! tuple_fold {
    ($($n:ident),*) => {
        impl<$($n: Fold<I, TI>,)* I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ($($n,)*) {
            type Result = ($($n::Result,)*);
            fn fold_with<'i>(&self, folder: &mut dyn Folder<'i, I, TI>, outer_binder: DebruijnIndex) -> Fallible<Self::Result>
            where
                I: 'i,
                TI: 'i,
            {
                #[allow(non_snake_case)]
                let &($(ref $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, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Option<T> {
    type Result = Option<T::Result>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        match self {
            None => Ok(None),
            Some(e) => Ok(Some(e.fold_with(folder, outer_binder)?)),
        }
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for GenericArg<I> {
    type Result = GenericArg<TI>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let interner = folder.interner();
        let target_interner = folder.target_interner();

        let data = self.data(interner).fold_with(folder, outer_binder)?;
        Ok(GenericArg::new(target_interner, data))
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Substitution<I> {
    type Result = Substitution<TI>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let interner = folder.interner();
        let target_interner = folder.target_interner();
        let folded = self
            .iter(interner)
            .map(|p| p.fold_with(folder, outer_binder));
        Ok(Substitution::from_fallible(target_interner, folded)?)
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Goals<I> {
    type Result = Goals<TI>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let interner = folder.interner();
        let target_interner = folder.target_interner();
        let folded = self
            .iter(interner)
            .map(|p| p.fold_with(folder, outer_binder));
        Ok(Goals::from_fallible(target_interner, folded)?)
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ProgramClauses<I> {
    type Result = ProgramClauses<TI>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let interner = folder.interner();
        let target_interner = folder.target_interner();
        let folded = self
            .iter(interner)
            .map(|p| p.fold_with(folder, outer_binder));
        Ok(ProgramClauses::from_fallible(target_interner, folded)?)
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for QuantifiedWhereClauses<I> {
    type Result = QuantifiedWhereClauses<TI>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let interner = folder.interner();
        let target_interner = folder.target_interner();
        let folded = self
            .iter(interner)
            .map(|p| p.fold_with(folder, outer_binder));
        Ok(QuantifiedWhereClauses::from_fallible(
            target_interner,
            folded,
        )?)
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Constraints<I> {
    type Result = Constraints<TI>;
    fn fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let interner = folder.interner();
        let target_interner = folder.target_interner();
        let folded = self
            .iter(interner)
            .map(|p| p.fold_with(folder, outer_binder));
        Ok(Constraints::from_fallible(target_interner, folded)?)
    }
}

#[doc(hidden)]
#[macro_export]
macro_rules! copy_fold {
    ($t:ty) => {
        impl<I: Interner, TI: TargetInterner<I>> $crate::fold::Fold<I, TI> for $t {
            type Result = Self;
            fn fold_with<'i>(
                &self,
                _folder: &mut dyn ($crate::fold::Folder<'i, I, TI>),
                _outer_binder: DebruijnIndex,
            ) -> ::chalk_ir::Fallible<Self::Result>
            where
                I: 'i,
                TI: 'i,
            {
                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) => {
        $crate::id_fold!($t, transfer_def_id);
    };

    ($t:ident, $transfer_fn:ident) => {
        impl<I: Interner, TI: TargetInterner<I>> $crate::fold::Fold<I, TI> for $t<I> {
            type Result = $t<TI>;
            fn fold_with<'i>(
                &self,
                _folder: &mut dyn ($crate::fold::Folder<'i, I, TI>),
                _outer_binder: DebruijnIndex,
            ) -> ::chalk_ir::Fallible<Self::Result>
            where
                I: 'i,
                TI: 'i,
            {
                let $t(def_id_tf) = *self;
                let def_id_ttf = TI::$transfer_fn(def_id_tf);
                Ok($t(def_id_ttf))
            }
        }
    };
}

id_fold!(ImplId);
id_fold!(AdtId, transfer_adt_id);
id_fold!(TraitId);
id_fold!(AssocTypeId);
id_fold!(OpaqueTyId);
id_fold!(FnDefId);
id_fold!(ClosureId);

impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<I> {
    fn super_fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> ::chalk_ir::Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?))
    }
}

impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
    fn super_fold_with<'i>(
        &self,
        folder: &mut dyn Folder<'i, I, TI>,
        outer_binder: DebruijnIndex,
    ) -> ::chalk_ir::Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        let clause = self.data(folder.interner());
        Ok(clause
            .super_fold_with(folder, outer_binder)?
            .intern(folder.target_interner()))
    }
}

impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I> {
    type Result = PhantomData<TI>;

    fn fold_with<'i>(
        &self,
        _folder: &mut dyn Folder<'i, I, TI>,
        _outer_binder: DebruijnIndex,
    ) -> ::chalk_ir::Fallible<Self::Result>
    where
        I: 'i,
        TI: 'i,
    {
        Ok(PhantomData)
    }
}
Commit	Line	Data
f035d41b XL	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
1b1a35ee XL	216	impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Constraints<I> {
	217	type Result = Constraints<TI>;
	218	fn fold_with<'i>(
	219	&self,
	220	folder: &mut dyn Folder<'i, I, TI>,
	221	outer_binder: DebruijnIndex,
	222	) -> Fallible<Self::Result>
	223	where
	224	I: 'i,
	225	TI: 'i,
	226	{
	227	let interner = folder.interner();
	228	let target_interner = folder.target_interner();
	229	let folded = self
	230	.iter(interner)
	231	.map(\|p\| p.fold_with(folder, outer_binder));
	232	Ok(Constraints::from_fallible(target_interner, folded)?)
	233	}
	234	}
	235
	236	#[doc(hidden)]
f035d41b XL	237	#[macro_export]
	238	macro_rules! copy_fold {
	239	($t:ty) => {
	240	impl<I: Interner, TI: TargetInterner<I>> $crate::fold::Fold<I, TI> for $t {
	241	type Result = Self;
	242	fn fold_with<'i>(
	243	&self,
	244	_folder: &mut dyn ($crate::fold::Folder<'i, I, TI>),
	245	_outer_binder: DebruijnIndex,
	246	) -> ::chalk_ir::Fallible<Self::Result>
	247	where
	248	I: 'i,
	249	TI: 'i,
	250	{
	251	Ok(*self)
	252	}
	253	}
	254	};
	255	}
	256
	257	copy_fold!(bool);
	258	copy_fold!(usize);
	259	copy_fold!(UniverseIndex);
	260	copy_fold!(PlaceholderIndex);
	261	copy_fold!(QuantifierKind);
	262	copy_fold!(DebruijnIndex);
	263	copy_fold!(());
	264	copy_fold!(UintTy);
	265	copy_fold!(IntTy);
	266	copy_fold!(FloatTy);
	267	copy_fold!(Scalar);
	268	copy_fold!(ClausePriority);
	269	copy_fold!(Mutability);
1b1a35ee	270	copy_fold!(Safety);
f035d41b	271
1b1a35ee	272	#[doc(hidden)]
f035d41b XL	273	#[macro_export]
	274	macro_rules! id_fold {
	275	($t:ident) => {
	276	$crate::id_fold!($t, transfer_def_id);
	277	};
	278
	279	($t:ident, $transfer_fn:ident) => {
	280	impl<I: Interner, TI: TargetInterner<I>> $crate::fold::Fold<I, TI> for $t<I> {
	281	type Result = $t<TI>;
	282	fn fold_with<'i>(
	283	&self,
	284	_folder: &mut dyn ($crate::fold::Folder<'i, I, TI>),
	285	_outer_binder: DebruijnIndex,
	286	) -> ::chalk_ir::Fallible<Self::Result>
	287	where
	288	I: 'i,
	289	TI: 'i,
	290	{
	291	let $t(def_id_tf) = *self;
	292	let def_id_ttf = TI::$transfer_fn(def_id_tf);
	293	Ok($t(def_id_ttf))
	294	}
	295	}
	296	};
	297	}
	298
	299	id_fold!(ImplId);
	300	id_fold!(AdtId, transfer_adt_id);
	301	id_fold!(TraitId);
	302	id_fold!(AssocTypeId);
	303	id_fold!(OpaqueTyId);
	304	id_fold!(FnDefId);
	305	id_fold!(ClosureId);
	306
	307	impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<I> {
	308	fn super_fold_with<'i>(
	309	&self,
	310	folder: &mut dyn Folder<'i, I, TI>,
	311	outer_binder: DebruijnIndex,
	312	) -> ::chalk_ir::Fallible<Self::Result>
	313	where
	314	I: 'i,
	315	TI: 'i,
	316	{
	317	Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?))
	318	}
	319	}
	320
	321	impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
	322	fn super_fold_with<'i>(
	323	&self,
	324	folder: &mut dyn Folder<'i, I, TI>,
	325	outer_binder: DebruijnIndex,
	326	) -> ::chalk_ir::Fallible<Self::Result>
	327	where
	328	I: 'i,
	329	TI: 'i,
	330	{
	331	let clause = self.data(folder.interner());
	332	Ok(clause
	333	.super_fold_with(folder, outer_binder)?
	334	.intern(folder.target_interner()))
	335	}
	336	}
337
338	impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I> {
339	type Result = PhantomData<TI>;
340
341	fn fold_with<'i>(
342	&self,
343	_folder: &mut dyn Folder<'i, I, TI>,
344	_outer_binder: DebruijnIndex,
345	) -> ::chalk_ir::Fallible<Self::Result>
346	where
347	I: 'i,
348	TI: 'i,
349	{
350	Ok(PhantomData)
351	}
352	}