start working on intern data

Author: yaahc

chalk-ir/src/could_match.rs

@@ -15,11 +15,13 @@ where
     fn could_match(&self, other: &T) -> bool {
         return Zip::zip_with(&mut MatchZipper, self, other).is_ok();
 
-        struct MatchZipper;
+        struct MatchZipper<'i, I> {
+            interner: &'i I,
+        };
 
-        impl<I: Interner> Zipper<I> for MatchZipper {
+        impl<I: Interner> Zipper<I> for MatchZipper<'_, I> {
             fn zip_tys(&mut self, a: &Ty<I>, b: &Ty<I>) -> Fallible<()> {
-                let could_match = match (a.data(), b.data()) {
+                let could_match = match (a.data(self.interner), b.data(self.interner)) {
                     (&TyData::Apply(ref a), &TyData::Apply(ref b)) => {
                         let names_could_match = a.name == b.name;
 

chalk-ir/src/fold.rs

@@ -303,7 +303,7 @@ where
         I: 'i,
         TI: 'i,
     {
-        match self.data() {
+        match self.data(folder.interner()) {
             TyData::BoundVar(depth) => {
                 if *depth >= binders {
                     folder.fold_free_var_ty(*depth - binders, binders)

chalk-ir/src/interner.rs

@@ -138,7 +138,7 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     fn intern_ty(&self, ty: TyData<Self>) -> Self::InternedType;
 
     /// Lookup the `TyData` from an interned type.
-    fn ty_data(ty: &Self::InternedType) -> &TyData<Self>;
+    fn ty_data<'a>(&self, ty: &'a Self::InternedType) -> &'a TyData<Self>;
 
     /// Create an "interned" lifetime from `lifetime`. This is not
     /// normally invoked directly; instead, you invoke
@@ -276,7 +276,7 @@ mod default {
             Arc::new(ty)
         }
 
-        fn ty_data(ty: &Arc<TyData<ChalkIr>>) -> &TyData<Self> {
+        fn ty_data<'a>(&self, ty: &'a Arc<TyData<ChalkIr>>) -> &'a TyData<Self> {
             ty
         }
 

chalk-ir/src/lib.rs

@@ -168,8 +168,8 @@ impl<I: Interner> Ty<I> {
         }
     }
 
-    pub fn data(&self) -> &TyData<I> {
-        I::ty_data(&self.interned)
+    pub fn data(&self, interner: &I) -> &TyData<I> {
+        I::ty_data(interner, &self.interned)
     }
 
     pub fn from_env(&self) -> FromEnv<I> {
@@ -181,25 +181,25 @@ impl<I: Interner> Ty<I> {
     }
 
     /// If this is a `TyData::BoundVar(d)`, returns `Some(d)` else `None`.
-    pub fn bound(&self) -> Option<usize> {
-        if let TyData::BoundVar(depth) = self.data() {
+    pub fn bound(&self, interner: &I) -> Option<usize> {
+        if let TyData::BoundVar(depth) = self.data(interner) {
             Some(*depth)
         } else {
             None
         }
     }
 
     /// If this is a `TyData::InferenceVar(d)`, returns `Some(d)` else `None`.
-    pub fn inference_var(&self) -> Option<InferenceVar> {
-        if let TyData::InferenceVar(depth) = self.data() {
+    pub fn inference_var(&self, interner: &I) -> Option<InferenceVar> {
+        if let TyData::InferenceVar(depth) = self.data(interner) {
             Some(*depth)
         } else {
             None
         }
     }
 
-    pub fn is_alias(&self) -> bool {
-        match self.data() {
+    pub fn is_alias(&self, interner: &I) -> bool {
+        match self.data(interner) {
             TyData::Alias(..) => true,
             _ => false,
         }
@@ -1009,11 +1009,12 @@ pub struct UCanonical<T> {
 impl<T> UCanonical<T> {
     pub fn is_trivial_substitution<I: Interner>(
         &self,
+        interner: &I,
         canonical_subst: &Canonical<AnswerSubst<I>>,
     ) -> bool {
         let subst = &canonical_subst.value.subst;
         assert_eq!(self.canonical.binders.len(), subst.parameters().len());
-        subst.is_identity_subst()
+        subst.is_identity_subst(interner)
     }
 }
 
@@ -1293,11 +1294,11 @@ impl<I: Interner> Substitution<I> {
     ///
     /// Basically, each value is mapped to a type or lifetime with its
     /// same index.
-    pub fn is_identity_subst(&self) -> bool {
+    pub fn is_identity_subst(&self, interner: &I) -> bool {
         self.iter()
             .zip(0..)
             .all(|(parameter, index)| match parameter.data() {
-                ParameterKind::Ty(ty) => match ty.data() {
+                ParameterKind::Ty(ty) => match ty.data(interner) {
                     TyData::BoundVar(depth) => index == *depth,
                     _ => false,
                 },