Make ty_data return TyData and add ty_kind

Author: jackh726

book/src/types/role_of_interner.md

@@ -52,8 +52,8 @@ type [`InternedTy`] and two related methods, [`intern_ty`] and [`ty_data`]:
 trait Interner {
     type InternedTy;
 
-    fn intern_ty(&self, data: &TyKind<Self>) -> Self::InternedTy;
-    fn ty_data(data: &Self::InternedTy) -> &TyKind<Self>;
+    fn intern_ty(&self, data: &TyData<Self>) -> Self::InternedTy;
+    fn ty_data(data: &Self::InternedTy) -> &TyData<Self>;
 }
 ```
 

chalk-engine/src/slg.rs

@@ -371,7 +371,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
     /// Returns true if the two types could be unequal.
     fn aggregate_tys(&mut self, new: &Ty<I>, current: &Ty<I>) -> bool {
         let interner = self.interner;
-        match (new.data(interner), current.data(interner)) {
+        match (new.kind(interner), current.kind(interner)) {
             (_, TyKind::BoundVar(_)) => {
                 // If the aggregate solution already has an inference
                 // variable here, then no matter what type we produce,

chalk-engine/src/slg/aggregate.rs

@@ -231,7 +231,7 @@ struct AntiUnifier<'infer, 'intern, I: Interner> {
 impl<I: Interner> AntiUnifier<'_, '_, I> {
     fn aggregate_tys(&mut self, ty0: &Ty<I>, ty1: &Ty<I>) -> Ty<I> {
         let interner = self.interner;
-        match (ty0.data(interner), ty1.data(interner)) {
+        match (ty0.kind(interner), ty1.kind(interner)) {
             // If we see bound things on either side, just drop in a
             // fresh variable. This means we will sometimes
             // overgeneralize.  So for example if we have two

chalk-engine/src/slg/resolvent.rs

@@ -373,7 +373,7 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
         // "inputs" to the subgoal table. We need to extract the
         // resulting answer that the subgoal found and unify it with
         // the value from our "pending subgoal".
-        if let TyKind::BoundVar(answer_depth) = answer.data(interner) {
+        if let TyKind::BoundVar(answer_depth) = answer.kind(interner) {
             if self.unify_free_answer_var(
                 interner,
                 *answer_depth,
@@ -385,7 +385,7 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
 
         // Otherwise, the answer and the selected subgoal ought to be a perfect match for
         // one another.
-        match (answer.data(interner), pending.data(interner)) {
+        match (answer.kind(interner), pending.kind(interner)) {
             (TyKind::BoundVar(answer_depth), TyKind::BoundVar(pending_depth)) => {
                 self.assert_matching_vars(*answer_depth, *pending_depth)
             }

chalk-integration/src/interner.rs

@@ -4,11 +4,11 @@ use chalk_ir::{
     AdtId, AliasTy, ApplicationTy, AssocTypeId, CanonicalVarKind, CanonicalVarKinds, ConstData,
     Constraint, FnDefId, Goals, InEnvironment, Lifetime, OpaqueTy, OpaqueTyId,
     ProgramClauseImplication, ProgramClauses, ProjectionTy, QuantifiedWhereClauses,
-    SeparatorTraitRef, Substitution, TraitId, Ty, VariableKind, VariableKinds,
+    SeparatorTraitRef, Substitution, TraitId, Ty, TyData, VariableKind, VariableKinds,
 };
 use chalk_ir::{
     GenericArg, GenericArgData, Goal, GoalData, LifetimeData, ProgramClause, ProgramClauseData,
-    QuantifiedWhereClause, TyKind,
+    QuantifiedWhereClause,
 };
 use std::fmt;
 use std::fmt::Debug;
@@ -40,7 +40,7 @@ pub enum ChalkFnAbi {
 pub struct ChalkIr;
 
 impl Interner for ChalkIr {
-    type InternedType = Arc<TyKind<ChalkIr>>;
+    type InternedType = Arc<TyData<ChalkIr>>;
     type InternedLifetime = LifetimeData<ChalkIr>;
     type InternedConst = Arc<ConstData<ChalkIr>>;
     type InternedConcreteConst = u32;
@@ -212,11 +212,11 @@ impl Interner for ChalkIr {
         tls::with_current_program(|prog| Some(prog?.debug_quantified_where_clauses(clauses, fmt)))
     }
 
-    fn intern_ty(&self, ty: TyKind<ChalkIr>) -> Arc<TyKind<ChalkIr>> {
+    fn intern_ty(&self, ty: TyData<ChalkIr>) -> Arc<TyData<ChalkIr>> {
         Arc::new(ty)
     }
 
-    fn ty_data<'a>(&self, ty: &'a Arc<TyKind<ChalkIr>>) -> &'a TyKind<Self> {
+    fn ty_data<'a>(&self, ty: &'a Arc<TyData<ChalkIr>>) -> &'a TyData<Self> {
         ty
     }
 
@@ -236,7 +236,7 @@ impl Interner for ChalkIr {
         constant
     }
 
-    fn const_eq(&self, _ty: &Arc<TyKind<ChalkIr>>, c1: &u32, c2: &u32) -> bool {
+    fn const_eq(&self, _ty: &Arc<TyData<ChalkIr>>, c1: &u32, c2: &u32) -> bool {
         c1 == c2
     }
 

chalk-integration/src/lowering.rs

@@ -120,11 +120,18 @@ impl Lower for VariableKind {
     type Lowered = chalk_ir::WithKind<ChalkIr, Ident>;
     fn lower(&self) -> Self::Lowered {
         let (kind, n) = match self {
-            VariableKind::Ty(n) => (chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General), n),
-            VariableKind::IntegerTy(n) => {
-                (chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::Integer), n)
-            }
-            VariableKind::FloatTy(n) => (chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::Float), n),
+            VariableKind::Ty(n) => (
+                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                n,
+            ),
+            VariableKind::IntegerTy(n) => (
+                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::Integer),
+                n,
+            ),
+            VariableKind::FloatTy(n) => (
+                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::Float),
+                n,
+            ),
             VariableKind::Lifetime(n) => (chalk_ir::VariableKind::Lifetime, n),
             VariableKind::Const(ref n) => (chalk_ir::VariableKind::Const(get_type_of_u32()), n),
         };

chalk-integration/src/program.rs

@@ -460,7 +460,7 @@ impl RustIrDatabase<ChalkIr> for Program {
                 .skip_binders()
                 .trait_ref
                 .self_type_parameter(interner);
-            match ty.data(interner) {
+            match ty.kind(interner) {
                 TyKind::Apply(app) => Some(app.clone()),
                 _ => None,
             }

chalk-ir/src/could_match.rs

@@ -26,8 +26,8 @@ where
         impl<'i, I: Interner> Zipper<'i, I> for MatchZipper<'i, I> {
             fn zip_tys(&mut self, a: &Ty<I>, b: &Ty<I>) -> Fallible<()> {
                 let interner = self.interner;
-                let could_match = match (a.data(interner), b.data(interner)) {
-                    (&TyKind::Apply(ref a), &TyKind::Apply(ref b)) => {
+                let could_match = match (a.kind(interner), b.kind(interner)) {
+                    (TyKind::Apply(ref a), TyKind::Apply(ref b)) => {
                         let names_could_match = a.name == b.name;
 
                         names_could_match

chalk-ir/src/debug.rs

@@ -220,6 +220,12 @@ impl<I: Interner> Debug for TypeName<I> {
     }
 }
 
+impl<I: Interner> Debug for TyData<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        self.kind.fmt(fmt)
+    }
+}
+
 impl<I: Interner> Debug for TyKind<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match self {
@@ -871,8 +877,12 @@ impl<I: Interner, T: Debug> Debug for WithKind<I, T> {
         let value = self.skip_kind();
         match &self.kind {
             VariableKind::Ty(TyVariableKind::General) => write!(fmt, "{:?} with kind type", value),
-            VariableKind::Ty(TyVariableKind::Integer) => write!(fmt, "{:?} with kind integer type", value),
-            VariableKind::Ty(TyVariableKind::Float) => write!(fmt, "{:?} with kind float type", value),
+            VariableKind::Ty(TyVariableKind::Integer) => {
+                write!(fmt, "{:?} with kind integer type", value)
+            }
+            VariableKind::Ty(TyVariableKind::Float) => {
+                write!(fmt, "{:?} with kind float type", value)
+            }
             VariableKind::Lifetime => write!(fmt, "{:?} with kind lifetime", value),
             VariableKind::Const(ty) => write!(fmt, "{:?} with kind {:?}", value, ty),
         }

chalk-ir/src/fold.rs

@@ -407,7 +407,7 @@ where
         TI: 'i,
     {
         let interner = folder.interner();
-        match self.data(interner) {
+        match self.kind(interner) {
             TyKind::BoundVar(bound_var) => {
                 if let Some(bound_var1) = bound_var.shifted_out_to(outer_binder) {
                     // This variable was bound outside of the binders