chalk_ir/fold/
binder_impls.rs

1//! This module contains impls of `TypeFoldable` for those types that
2//! introduce binders.
3//!
4//! The more interesting impls of `TypeFoldable` remain in the `fold` module.
5
6use crate::*;
7
8impl<I: Interner> TypeFoldable<I> for FnPointer<I> {
9    fn try_fold_with<E>(
10        self,
11        folder: &mut dyn FallibleTypeFolder<I, Error = E>,
12        outer_binder: DebruijnIndex,
13    ) -> Result<Self, E> {
14        let FnPointer {
15            num_binders,
16            substitution,
17            sig,
18        } = self;
19        Ok(FnPointer {
20            num_binders,
21            substitution: substitution.try_fold_with(folder, outer_binder.shifted_in())?,
22            sig: FnSig {
23                abi: sig.abi,
24                safety: sig.safety,
25                variadic: sig.variadic,
26            },
27        })
28    }
29}
30
31impl<T, I: Interner> TypeFoldable<I> for Binders<T>
32where
33    T: HasInterner<Interner = I> + TypeFoldable<I>,
34    I: Interner,
35{
36    fn try_fold_with<E>(
37        self,
38        folder: &mut dyn FallibleTypeFolder<I, Error = E>,
39        outer_binder: DebruijnIndex,
40    ) -> Result<Self, E> {
41        let Binders {
42            binders: self_binders,
43            value: self_value,
44        } = self;
45        let value = self_value.try_fold_with(folder, outer_binder.shifted_in())?;
46        let binders = VariableKinds {
47            interned: self_binders.interned().clone(),
48        };
49        Ok(Binders::new(binders, value))
50    }
51}
52
53impl<I, T> TypeFoldable<I> for Canonical<T>
54where
55    I: Interner,
56    T: HasInterner<Interner = I> + TypeFoldable<I>,
57{
58    fn try_fold_with<E>(
59        self,
60        folder: &mut dyn FallibleTypeFolder<I, Error = E>,
61        outer_binder: DebruijnIndex,
62    ) -> Result<Self, E> {
63        let Canonical {
64            binders: self_binders,
65            value: self_value,
66        } = self;
67        let value = self_value.try_fold_with(folder, outer_binder.shifted_in())?;
68        let binders = CanonicalVarKinds {
69            interned: self_binders.interned().clone(),
70        };
71        Ok(Canonical { binders, value })
72    }
73}