Chalkify TraitRef

2 files changed, 12 insertions, 13 deletions

diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index bef6e7e9c..bac70f5aa 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -19,7 +19,7 @@ use crate::{
     display::HirDisplay,
     from_assoc_type_id,
     method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
-    to_assoc_type_id,
+    to_assoc_type_id, to_chalk_trait_id,
     utils::generics,
     BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
     ProjectionPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
@@ -219,9 +219,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                     // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
                     //     ^1  ^0            ^0                    ^0      ^1
                     let impl_bound = GenericPredicate::Implemented(TraitRef {
-                        trait_: future_trait,
+                        trait_id: to_chalk_trait_id(future_trait),
                         // Self type as the first parameter.
-                        substs: Substitution::single(
+                        substitution: Substitution::single(
                             TyKind::BoundVar(BoundVar {
                                 debruijn: DebruijnIndex::INNERMOST,
                                 index: 0,
@@ -546,7 +546,7 @@ fn impl_def_datum(
 
     let generic_params = generics(db.upcast(), impl_id.into());
     let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
-    let trait_ = trait_ref.trait_;
+    let trait_ = trait_ref.hir_trait_id();
     let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
         rust_ir::ImplType::Local
     } else {
@@ -614,7 +614,7 @@ fn type_alias_associated_ty_value(
     let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist").value; // we don't return any assoc ty values if the impl'd trait can't be resolved
 
     let assoc_ty = db
-        .trait_data(trait_ref.trait_)
+        .trait_data(trait_ref.hir_trait_id())
         .associated_type_by_name(&type_alias_data.name)
         .expect("assoc ty value should not exist"); // validated when building the impl data as well
     let ty = db.ty(type_alias.into());
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index d969527dc..0086ce1e9 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -239,15 +239,15 @@ impl ToChalk for TraitRef {
     type Chalk = chalk_ir::TraitRef<Interner>;
 
     fn to_chalk(self: TraitRef, db: &dyn HirDatabase) -> chalk_ir::TraitRef<Interner> {
-        let trait_id = self.trait_.to_chalk(db);
-        let substitution = self.substs.to_chalk(db);
+        let trait_id = self.trait_id;
+        let substitution = self.substitution.to_chalk(db);
         chalk_ir::TraitRef { trait_id, substitution }
     }
 
     fn from_chalk(db: &dyn HirDatabase, trait_ref: chalk_ir::TraitRef<Interner>) -> Self {
-        let trait_ = from_chalk(db, trait_ref.trait_id);
+        let trait_id = trait_ref.trait_id;
         let substs = from_chalk(db, trait_ref.substitution);
-        TraitRef { trait_, substs }
+        TraitRef { trait_id, substitution: substs }
     }
 }
 
@@ -515,17 +515,16 @@ pub(super) fn generic_predicate_to_inline_bound(
     // We don't have a special type for this, but Chalk does.
     match pred {
         GenericPredicate::Implemented(trait_ref) => {
-            if &trait_ref.substs[0] != self_ty {
+            if &trait_ref.substitution[0] != self_ty {
                 // we can only convert predicates back to type bounds if they
                 // have the expected self type
                 return None;
             }
-            let args_no_self = trait_ref.substs[1..]
+            let args_no_self = trait_ref.substitution[1..]
                 .iter()
                 .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                 .collect();
-            let trait_bound =
-                rust_ir::TraitBound { trait_id: trait_ref.trait_.to_chalk(db), args_no_self };
+            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
             Some(rust_ir::InlineBound::TraitBound(trait_bound))
         }
         GenericPredicate::Projection(proj) => {