intern the parameter list

It is constructed from an iterator over results

Author: nikomatsakis

chalk-ir/src/debug.rs

@@ -409,7 +409,7 @@ impl<TF: TypeFamily> Substitution<TF> {
     /// Displays the substitution in the form `< P0, .. Pn >`, or (if
     /// the substitution is empty) as an empty string.
     pub fn with_angle(&self) -> Angle<'_, Parameter<TF>> {
-        Angle(&self.parameters)
+        Angle(self.parameters())
     }
 }
 

chalk-ir/src/family.rs

@@ -2,6 +2,7 @@ use crate::tls;
 use crate::AssocTypeId;
 use crate::GoalData;
 use crate::LifetimeData;
+use crate::Parameter;
 use crate::ParameterData;
 use crate::ProjectionTy;
 use crate::RawId;
@@ -68,6 +69,14 @@ pub trait TypeFamily: Debug + Copy + Eq + Ord + Hash {
     /// converted back to its underlying data via `goal_data`.
     type InternedGoal: Debug + Clone + Eq + Ord + Hash;
 
+    /// "Interned" representation of a "substitution".  In normal user code,
+    /// `Self::InternedSubstitution` is not referenced. Instead, we refer to
+    /// `Substitution<Self>`, which wraps this type.
+    ///
+    /// An `InternedSubstitution` is created by `intern_substitution` and can be
+    /// converted back to its underlying data via `substitution_data`.
+    type InternedSubstitution: Debug + Clone + Eq + Ord + Hash;
+
     /// The core "id" type used for struct-ids and the like.
     type DefId: Debug + Copy + Eq + Ord + Hash;
 
@@ -146,8 +155,19 @@ pub trait TypeFamily: Debug + Copy + Eq + Ord + Hash {
     /// method).
     fn intern_goal(data: GoalData<Self>) -> Self::InternedGoal;
 
-    /// Lookup the `GoalData` that was interned to create a `InternedGoal`.
+    /// Lookup the `LifetimeData` that was interned to create a `InternedLifetime`.
     fn goal_data(lifetime: &Self::InternedGoal) -> &GoalData<Self>;
+
+    /// Create an "interned" substitution from `data`. This is not
+    /// normally invoked directly; instead, you invoke
+    /// `SubstitutionData::intern` (which will ultimately call this
+    /// method).
+    fn intern_substitution<E>(
+        data: impl IntoIterator<Item = Result<Parameter<Self>, E>>,
+    ) -> Result<Self::InternedSubstitution, E>;
+
+    /// Lookup the `SubstitutionData` that was interned to create a `InternedSubstitution`.
+    fn substitution_data(lifetime: &Self::InternedSubstitution) -> &[Parameter<Self>];
 }
 
 pub trait TargetTypeFamily<TF: TypeFamily>: TypeFamily {
@@ -181,6 +201,7 @@ impl TypeFamily for ChalkIr {
     type InternedLifetime = LifetimeData<ChalkIr>;
     type InternedParameter = ParameterData<ChalkIr>;
     type InternedGoal = Arc<GoalData<ChalkIr>>;
+    type InternedSubstitution = Vec<Parameter<ChalkIr>>;
     type DefId = RawId;
 
     fn debug_struct_id(
@@ -242,6 +263,16 @@ impl TypeFamily for ChalkIr {
     fn goal_data(goal: &Arc<GoalData<ChalkIr>>) -> &GoalData<ChalkIr> {
         goal
     }
+
+    fn intern_substitution<E>(
+        data: impl IntoIterator<Item = Result<Parameter<ChalkIr>, E>>,
+    ) -> Result<Vec<Parameter<ChalkIr>>, E> {
+        data.into_iter().collect()
+    }
+
+    fn substitution_data(substitution: &Vec<Parameter<ChalkIr>>) -> &[Parameter<ChalkIr>] {
+        substitution
+    }
 }
 
 impl HasTypeFamily for ChalkIr {

chalk-ir/src/fold/boring_impls.rs

@@ -86,6 +86,7 @@ impl<T: Fold<TF, TTF>, TF: TypeFamily, TTF: TargetTypeFamily<TF>> Fold<TF, TTF>
         }
     }
 }
+
 impl<TF: TypeFamily, TTF: TargetTypeFamily<TF>> Fold<TF, TTF> for Parameter<TF> {
     type Result = Parameter<TTF>;
     fn fold_with(
@@ -110,6 +111,19 @@ impl<TF: TypeFamily, TTF: TargetTypeFamily<TF>> Fold<TF, TTF> for Goal<TF> {
     }
 }
 
+impl<TF: TypeFamily, TTF: TargetTypeFamily<TF>> Fold<TF, TTF> for Substitution<TF> {
+    type Result = Substitution<TTF>;
+    fn fold_with(
+        &self,
+        folder: &mut dyn Folder<TF, TTF>,
+        binders: usize,
+    ) -> Fallible<Self::Result> {
+        Ok(Substitution::from_fallible(
+            self.iter().map(|p| p.fold_with(folder, binders)),
+        )?)
+    }
+}
+
 #[macro_export]
 macro_rules! copy_fold {
     ($t:ty) => {

chalk-ir/src/lib.rs

@@ -1176,27 +1176,31 @@ pub enum Constraint<TF: TypeFamily> {
 }
 
 /// A mapping of inference variables to instantiations thereof.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Fold, Hash, HasTypeFamily)]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HasTypeFamily)]
 pub struct Substitution<TF: TypeFamily> {
     /// Map free variable with given index to the value with the same
     /// index. Naturally, the kind of the variable must agree with
     /// the kind of the value.
-    parameters: Vec<Parameter<TF>>,
+    parameters: TF::InternedSubstitution,
 }
 
 impl<TF: TypeFamily> Substitution<TF> {
     pub fn from(parameters: impl IntoIterator<Item = impl CastTo<Parameter<TF>>>) -> Self {
-        use crate::cast::Caster;
-        let parameters = parameters.into_iter().casted().collect();
-        Substitution { parameters }
+        Self::from_fallible(
+            parameters
+                .into_iter()
+                .map(|p| -> Result<Parameter<TF>, ()> { Ok(p.cast()) }),
+        )
+        .unwrap()
     }
 
     pub fn from_fallible<E>(
         parameters: impl IntoIterator<Item = Result<impl CastTo<Parameter<TF>>, E>>,
     ) -> Result<Self, E> {
         use crate::cast::Caster;
-        let parameters: Result<Vec<Parameter<TF>>, E> = parameters.into_iter().casted().collect();
-        Ok(Substitution::from(parameters?))
+        Ok(Substitution {
+            parameters: TF::intern_substitution(parameters.into_iter().casted())?,
+        })
     }
 
     /// Index into the list of parameters
@@ -1221,7 +1225,7 @@ impl<TF: TypeFamily> Substitution<TF> {
     }
 
     pub fn parameters(&self) -> &[Parameter<TF>] {
-        &self.parameters
+        TF::substitution_data(&self.parameters)
     }
 
     pub fn len(&self) -> usize {

chalk-ir/src/zip.rs

@@ -179,9 +179,6 @@ macro_rules! struct_zip {
     }
 }
 
-struct_zip!(impl[TF: TypeFamily] Zip<TF> for Substitution<TF> {
-    parameters,
-});
 struct_zip!(impl[TF: TypeFamily] Zip<TF> for TraitRef<TF> {
     trait_id,
     substitution,
@@ -256,6 +253,12 @@ enum_zip!(impl<TF> for DomainGoal<TF> {
 });
 enum_zip!(impl<TF> for ProgramClause<TF> { Implies, ForAll });
 
+impl<TF: TypeFamily> Zip<TF> for Substitution<TF> {
+    fn zip_with<Z: Zipper<TF>>(zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()> {
+        Zip::zip_with(zipper, a.parameters(), b.parameters())
+    }
+}
+
 // Annoyingly, Goal cannot use `enum_zip` because some variants have
 // two parameters, and I'm too lazy to make the macro account for the
 // relevant name mangling.