2 files changed, 20 insertions, 36 deletions

diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 3f5f5091f..e513fa8f4 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -90,7 +90,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
             ty: &Ty,
             binders: &CanonicalVarKinds<Interner>,
         ) -> Option<chalk_ir::TyVariableKind> {
-            if let Ty::Bound(bv) = ty {
+            if let Ty::BoundVar(bv) = ty {
                 let binders = binders.as_slice(&Interner);
                 if bv.debruijn == DebruijnIndex::INNERMOST {
                     if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind {
@@ -220,18 +220,18 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                     let impl_bound = GenericPredicate::Implemented(TraitRef {
                         trait_: future_trait,
                         // Self type as the first parameter.
-                        substs: Substs::single(Ty::Bound(BoundVar {
+                        substs: Substs::single(Ty::BoundVar(BoundVar {
                             debruijn: DebruijnIndex::INNERMOST,
                             index: 0,
                         })),
                     });
                     let proj_bound = GenericPredicate::Projection(ProjectionPredicate {
                         // The parameter of the opaque type.
-                        ty: Ty::Bound(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }),
+                        ty: Ty::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }),
                         projection_ty: ProjectionTy {
                             associated_ty: future_output,
                             // Self type as the first parameter.
-                            parameters: Substs::single(Ty::Bound(BoundVar::new(
+                            parameters: Substs::single(Ty::BoundVar(BoundVar::new(
                                 DebruijnIndex::INNERMOST,
                                 0,
                             ))),
@@ -392,7 +392,7 @@ pub(crate) fn associated_ty_data_query(
     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
     let ctx = crate::TyLoweringContext::new(db, &resolver)
         .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
-    let self_ty = Ty::Bound(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0));
+    let self_ty = Ty::BoundVar(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0));
     let bounds = type_alias_data
         .bounds
         .iter()
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 995ff6a9a..db1760e6c 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -10,14 +10,14 @@ use chalk_ir::{
 use chalk_solve::rust_ir;
 
 use base_db::salsa::InternKey;
-use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, TypeAliasId};
+use hir_def::{AssocContainerId, GenericDefId, Lookup, TypeAliasId};
 
 use crate::{
     db::HirDatabase,
     primitive::UintTy,
     traits::{Canonical, Obligation},
-    CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
-    ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty,
+    AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy,
+    OpaqueTyId, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitEnvironment, TraitRef, Ty,
 };
 
 use super::interner::*;
@@ -63,9 +63,9 @@ impl ToChalk for Ty {
                 let substitution = substs.to_chalk(db);
                 chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
             }
-            Ty::RawPtr(mutability, substs) => {
+            Ty::Raw(mutability, substs) => {
                 let ty = substs[0].clone().to_chalk(db);
-                chalk_ir::TyKind::Raw(mutability.to_chalk(db), ty).intern(&Interner)
+                chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner)
             }
             Ty::Slice(substs) => {
                 chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner)
@@ -88,7 +88,7 @@ impl ToChalk for Ty {
                 let substitution = substs.to_chalk(db);
                 chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
             }
-            Ty::Projection(proj_ty) => {
+            Ty::Alias(AliasTy::Projection(proj_ty)) => {
                 let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db);
                 let substitution = proj_ty.parameters.to_chalk(db);
                 chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
@@ -106,7 +106,7 @@ impl ToChalk for Ty {
                 }
                 .to_ty::<Interner>(&Interner)
             }
-            Ty::Bound(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
+            Ty::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
             Ty::InferenceVar(..) => panic!("uncanonicalized infer ty"),
             Ty::Dyn(predicates) => {
                 let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
@@ -119,7 +119,7 @@ impl ToChalk for Ty {
                 };
                 chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
             }
-            Ty::Opaque(opaque_ty) => {
+            Ty::Alias(AliasTy::Opaque(opaque_ty)) => {
                 let opaque_ty_id = opaque_ty.opaque_ty_id.to_chalk(db);
                 let substitution = opaque_ty.parameters.to_chalk(db);
                 chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
@@ -146,12 +146,12 @@ impl ToChalk for Ty {
                 let associated_ty =
                     from_chalk::<TypeAliasAsAssocType, _>(db, proj.associated_ty_id).0;
                 let parameters = from_chalk(db, proj.substitution);
-                Ty::Projection(ProjectionTy { associated_ty, parameters })
+                Ty::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters }))
             }
             chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
                 let impl_trait_id = from_chalk(db, opaque_ty.opaque_ty_id);
                 let parameters = from_chalk(db, opaque_ty.substitution);
-                Ty::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters })
+                Ty::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters }))
             }
             chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                 num_binders,
@@ -170,7 +170,7 @@ impl ToChalk for Ty {
                     substs,
                 })
             }
-            chalk_ir::TyKind::BoundVar(idx) => Ty::Bound(idx),
+            chalk_ir::TyKind::BoundVar(idx) => Ty::BoundVar(idx),
             chalk_ir::TyKind::InferenceVar(_iv, _kind) => Ty::Unknown,
             chalk_ir::TyKind::Dyn(where_clauses) => {
                 assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
@@ -198,11 +198,11 @@ impl ToChalk for Ty {
                 Ty::Tuple(cardinality, from_chalk(db, subst))
             }
             chalk_ir::TyKind::Raw(mutability, ty) => {
-                Ty::RawPtr(from_chalk(db, mutability), Substs::single(from_chalk(db, ty)))
+                Ty::Raw(mutability, Substs::single(from_chalk(db, ty)))
             }
             chalk_ir::TyKind::Slice(ty) => Ty::Slice(Substs::single(from_chalk(db, ty))),
             chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                Ty::Ref(from_chalk(db, mutability), Substs::single(from_chalk(db, ty)))
+                Ty::Ref(mutability, Substs::single(from_chalk(db, ty)))
             }
             chalk_ir::TyKind::Str => Ty::Str,
             chalk_ir::TyKind::Never => Ty::Never,
@@ -230,12 +230,12 @@ impl ToChalk for Ty {
 /// fake lifetime here, because Chalks built-in logic may expect it to be there.
 fn ref_to_chalk(
     db: &dyn HirDatabase,
-    mutability: Mutability,
+    mutability: chalk_ir::Mutability,
     subst: Substs,
 ) -> chalk_ir::Ty<Interner> {
     let arg = subst[0].clone().to_chalk(db);
     let lifetime = LifetimeData::Static.intern(&Interner);
-    chalk_ir::TyKind::Ref(mutability.to_chalk(db), lifetime, arg).intern(&Interner)
+    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
 }
 
 /// We currently don't model constants, but Chalk does. So, we have to insert a
@@ -313,22 +313,6 @@ impl ToChalk for OpaqueTyId {
     }
 }
 
-impl ToChalk for Mutability {
-    type Chalk = chalk_ir::Mutability;
-    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
-        match self {
-            Mutability::Shared => chalk_ir::Mutability::Not,
-            Mutability::Mut => chalk_ir::Mutability::Mut,
-        }
-    }
-    fn from_chalk(_db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
-        match chalk {
-            chalk_ir::Mutability::Mut => Mutability::Mut,
-            chalk_ir::Mutability::Not => Mutability::Shared,
-        }
-    }
-}
-
 impl ToChalk for hir_def::ImplId {
     type Chalk = ImplId;