From 743faa21e74cc5b627935e2c4c3365807a5c722f Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Fri, 9 Apr 2021 14:11:37 +0200
Subject: [PATCH 1/6] Reorganize hir_ty modules

Chalk isn't really a 'traits' thing anymore, so it doesn't make sense to
have all the Chalk-related stuff in submodules of `traits`.
---
 .../src/{traits/chalk.rs => chalk_db.rs}      | 32 ++++++-------
 crates/hir_ty/src/db.rs                       | 47 +++++++++----------
 crates/hir_ty/src/display.rs                  |  2 +-
 crates/hir_ty/src/infer/expr.rs               |  3 +-
 .../hir_ty/src/{traits/chalk => }/interner.rs | 24 ++--------
 crates/hir_ty/src/lib.rs                      |  7 ++-
 crates/hir_ty/src/lower.rs                    |  3 +-
 .../hir_ty/src/{traits/chalk => }/mapping.rs  | 28 +++++------
 crates/hir_ty/src/{traits/chalk => }/tls.rs   |  9 ++--
 crates/hir_ty/src/traits.rs                   | 14 ++----
 10 files changed, 71 insertions(+), 98 deletions(-)
 rename crates/hir_ty/src/{traits/chalk.rs => chalk_db.rs} (94%)
 rename crates/hir_ty/src/{traits/chalk => }/interner.rs (91%)
 rename crates/hir_ty/src/{traits/chalk => }/mapping.rs (82%)
 rename crates/hir_ty/src/{traits/chalk => }/tls.rs (97%)

diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/chalk_db.rs
similarity index 94%
rename from crates/hir_ty/src/traits/chalk.rs
rename to crates/hir_ty/src/chalk_db.rs
index cd511477b9..566e4f406c 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -13,25 +13,23 @@ use hir_def::{
 };
 use hir_expand::name::name;
 
-use super::ChalkContext;
-use crate::{
-    db::HirDatabase,
-    display::HirDisplay,
-    from_assoc_type_id, make_only_type_binders,
-    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
-    to_assoc_type_id, to_chalk_trait_id,
-    utils::generics,
-    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, ProjectionTy, Substitution,
-    TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
-};
-use mapping::{convert_where_clauses, generic_predicate_to_inline_bound, TypeAliasAsValue};
+use crate::{AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause, traits::ChalkContext, db::HirDatabase, display::HirDisplay, from_assoc_type_id, make_only_type_binders, mapping::{convert_where_clauses, generic_predicate_to_inline_bound, TypeAliasAsValue}, method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS}, to_assoc_type_id, to_chalk_trait_id, utils::generics};
 
-pub use self::interner::Interner;
-pub(crate) use self::interner::*;
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
 
-pub(super) mod tls;
-mod interner;
-mod mapping;
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
+pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
+pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
+pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
+pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
+pub(crate) type Variances = chalk_ir::Variances<Interner>;
 
 pub(crate) trait ToChalk {
     type Chalk;
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index 326c202404..ea0580df16 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -9,12 +9,7 @@ use hir_def::{
 };
 use la_arena::ArenaMap;
 
-use crate::{
-    method_resolution::{InherentImpls, TraitImpls},
-    traits::chalk,
-    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, PolyFnSig,
-    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
-};
+use crate::{Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, Interner, PolyFnSig, QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db, method_resolution::{InherentImpls, TraitImpls}};
 use hir_expand::name::Name;
 
 #[salsa::query_group(HirDatabaseStorage)]
@@ -94,33 +89,33 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     #[salsa::interned]
     fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;
 
-    #[salsa::invoke(chalk::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
+    #[salsa::invoke(chalk_db::associated_ty_data_query)]
+    fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;
 
-    #[salsa::invoke(chalk::trait_datum_query)]
-    fn trait_datum(&self, krate: CrateId, trait_id: chalk::TraitId) -> Arc<chalk::TraitDatum>;
+    #[salsa::invoke(chalk_db::trait_datum_query)]
+    fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId) -> Arc<chalk_db::TraitDatum>;
 
-    #[salsa::invoke(chalk::struct_datum_query)]
-    fn struct_datum(&self, krate: CrateId, struct_id: chalk::AdtId) -> Arc<chalk::StructDatum>;
+    #[salsa::invoke(chalk_db::struct_datum_query)]
+    fn struct_datum(&self, krate: CrateId, struct_id: chalk_db::AdtId) -> Arc<chalk_db::StructDatum>;
 
-    #[salsa::invoke(crate::traits::chalk::impl_datum_query)]
-    fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>;
+    #[salsa::invoke(chalk_db::impl_datum_query)]
+    fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>;
 
-    #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)]
-    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk::FnDefDatum>;
+    #[salsa::invoke(chalk_db::fn_def_datum_query)]
+    fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk_db::FnDefDatum>;
 
-    #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)]
-    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk::Variances;
+    #[salsa::invoke(chalk_db::fn_def_variance_query)]
+    fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk_db::Variances;
 
-    #[salsa::invoke(crate::traits::chalk::adt_variance_query)]
-    fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances;
+    #[salsa::invoke(chalk_db::adt_variance_query)]
+    fn adt_variance(&self, krate: CrateId, adt_id: chalk_db::AdtId) -> chalk_db::Variances;
 
-    #[salsa::invoke(crate::traits::chalk::associated_ty_value_query)]
+    #[salsa::invoke(chalk_db::associated_ty_value_query)]
     fn associated_ty_value(
         &self,
         krate: CrateId,
-        id: chalk::AssociatedTyValueId,
-    ) -> Arc<chalk::AssociatedTyValue>;
+        id: chalk_db::AssociatedTyValueId,
+    ) -> Arc<chalk_db::AssociatedTyValue>;
 
     #[salsa::invoke(crate::traits::trait_solve_query)]
     fn trait_solve(
@@ -129,12 +124,12 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
         goal: crate::Canonical<crate::InEnvironment<crate::DomainGoal>>,
     ) -> Option<crate::Solution>;
 
-    #[salsa::invoke(crate::traits::chalk::program_clauses_for_chalk_env_query)]
+    #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]
     fn program_clauses_for_chalk_env(
         &self,
         krate: CrateId,
-        env: chalk_ir::Environment<chalk::Interner>,
-    ) -> chalk_ir::ProgramClauses<chalk::Interner>;
+        env: chalk_ir::Environment<Interner>,
+    ) -> chalk_ir::ProgramClauses<Interner>;
 }
 
 fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 92224b46b2..a0746cd8fa 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -21,7 +21,7 @@ use hir_expand::name::Name;
 use crate::{
     const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
     from_placeholder_idx, lt_from_placeholder_idx, primitive, subst_prefix, to_assoc_type_id,
-    traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId,
+    chalk_db::from_chalk, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId,
     CallableSig, Const, ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime,
     LifetimeData, LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt,
     QuantifiedWhereClause, Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 7961f4a529..d423830126 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -20,7 +20,8 @@ use crate::{
     method_resolution, op,
     primitive::{self, UintTy},
     static_lifetime, to_chalk_trait_id,
-    traits::{chalk::from_chalk, FnTrait},
+    traits::FnTrait,
+    chalk_db::from_chalk,
     utils::{generics, Generics},
     AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
     ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/interner.rs
similarity index 91%
rename from crates/hir_ty/src/traits/chalk/interner.rs
rename to crates/hir_ty/src/interner.rs
index b6a3cec6d5..0187767cec 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -1,8 +1,7 @@
 //! Implementation of the Chalk `Interner` trait, which allows customizing the
 //! representation of the various objects Chalk deals with (types, goals etc.).
 
-use super::tls;
-use crate::GenericArg;
+use crate::{GenericArg, tls, chalk_db};
 use base_db::salsa::InternId;
 use chalk_ir::{Goal, GoalData};
 use hir_def::{
@@ -15,21 +14,6 @@ use std::{fmt, sync::Arc};
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
 
-pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
-pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
-pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
-pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
-pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
-pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
-pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
-pub(crate) type Variances = chalk_ir::Variances<Interner>;
-
 #[derive(PartialEq, Eq, Hash, Debug)]
 pub struct InternedWrapper<T>(T);
 
@@ -76,15 +60,15 @@ impl chalk_ir::interner::Interner for Interner {
     type Identifier = TypeAliasId;
     type FnAbi = ();
 
-    fn debug_adt_id(type_kind_id: AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_adt_id(type_kind_id: chalk_db::AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))
     }
 
-    fn debug_trait_id(type_kind_id: TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_trait_id(type_kind_id: chalk_db::TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt)))
     }
 
-    fn debug_assoc_type_id(id: AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_assoc_type_id(id: chalk_db::AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
     }
 
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index beb58d7117..0743d3d30d 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -18,6 +18,10 @@ mod chalk_cast;
 mod chalk_ext;
 mod builder;
 mod walk;
+mod tls;
+mod interner;
+mod mapping;
+mod chalk_db;
 
 pub mod display;
 pub mod db;
@@ -51,8 +55,9 @@ pub use lower::{
     associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
     TyDefId, TyLoweringContext, ValueTyDefId,
 };
-pub use traits::{chalk::Interner, TraitEnvironment};
+pub use traits::TraitEnvironment;
 pub use walk::TypeWalk;
+pub use interner::Interner;
 
 pub use chalk_ir::{
     cast::Cast, AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind,
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 8a22d9ea35..0cdded3e1b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -28,7 +28,8 @@ use stdx::impl_from;
 use crate::{
     db::HirDatabase,
     dummy_usize_const, static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
-    traits::chalk::{Interner, ToChalk},
+    chalk_db::ToChalk,
+    Interner,
     utils::{
         all_super_trait_refs, associated_type_by_name_including_super_traits, generics, Generics,
     },
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/mapping.rs
similarity index 82%
rename from crates/hir_ty/src/traits/chalk/mapping.rs
rename to crates/hir_ty/src/mapping.rs
index e78581ea5b..4d3c41b2c4 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/mapping.rs
@@ -3,40 +3,34 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
 
-use chalk_ir::cast::Cast;
+use chalk_ir::{DebruijnIndex, cast::Cast, fold::Shift};
 use chalk_solve::rust_ir;
 
 use base_db::salsa::InternKey;
 use hir_def::{GenericDefId, TypeAliasId};
 
-use crate::{
-    db::HirDatabase, AliasTy, CallableDefId, ProjectionTyExt, QuantifiedWhereClause, Substitution,
-    Ty, WhereClause,
-};
-
-use super::interner::*;
-use super::*;
+use crate::{AliasEq, AliasTy, CallableDefId, FnDefId, Interner, ProjectionTyExt, QuantifiedWhereClause, Substitution, Ty, WhereClause, chalk_db::{self, ToChalk}, db::HirDatabase};
 
 impl ToChalk for hir_def::TraitId {
-    type Chalk = TraitId;
+    type Chalk = chalk_db::TraitId;
 
-    fn to_chalk(self, _db: &dyn HirDatabase) -> TraitId {
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::TraitId {
         chalk_ir::TraitId(self.as_intern_id())
     }
 
-    fn from_chalk(_db: &dyn HirDatabase, trait_id: TraitId) -> hir_def::TraitId {
+    fn from_chalk(_db: &dyn HirDatabase, trait_id: chalk_db::TraitId) -> hir_def::TraitId {
         InternKey::from_intern_id(trait_id.0)
     }
 }
 
 impl ToChalk for hir_def::ImplId {
-    type Chalk = ImplId;
+    type Chalk = chalk_db::ImplId;
 
-    fn to_chalk(self, _db: &dyn HirDatabase) -> ImplId {
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::ImplId {
         chalk_ir::ImplId(self.as_intern_id())
     }
 
-    fn from_chalk(_db: &dyn HirDatabase, impl_id: ImplId) -> hir_def::ImplId {
+    fn from_chalk(_db: &dyn HirDatabase, impl_id: chalk_db::ImplId) -> hir_def::ImplId {
         InternKey::from_intern_id(impl_id.0)
     }
 }
@@ -56,15 +50,15 @@ impl ToChalk for CallableDefId {
 pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
 
 impl ToChalk for TypeAliasAsValue {
-    type Chalk = AssociatedTyValueId;
+    type Chalk = chalk_db::AssociatedTyValueId;
 
-    fn to_chalk(self, _db: &dyn HirDatabase) -> AssociatedTyValueId {
+    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::AssociatedTyValueId {
         rust_ir::AssociatedTyValueId(self.0.as_intern_id())
     }
 
     fn from_chalk(
         _db: &dyn HirDatabase,
-        assoc_ty_value_id: AssociatedTyValueId,
+        assoc_ty_value_id: chalk_db::AssociatedTyValueId,
     ) -> TypeAliasAsValue {
         TypeAliasAsValue(TypeAliasId::from_intern_id(assoc_ty_value_id.0))
     }
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/tls.rs
similarity index 97%
rename from crates/hir_ty/src/traits/chalk/tls.rs
rename to crates/hir_ty/src/tls.rs
index 8892a63a9a..c319bcf704 100644
--- a/crates/hir_ty/src/traits/chalk/tls.rs
+++ b/crates/hir_ty/src/tls.rs
@@ -4,8 +4,7 @@ use std::fmt;
 use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication};
 use itertools::Itertools;
 
-use super::{from_chalk, Interner};
-use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId};
+use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId, chalk_db::{from_chalk, self}, Interner};
 use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
 
 pub(crate) use unsafe_tls::{set_current_program, with_current_program};
@@ -15,7 +14,7 @@ pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase);
 impl DebugContext<'_> {
     pub(crate) fn debug_struct_id(
         &self,
-        id: super::AdtId,
+        id: chalk_db::AdtId,
         f: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         let name = match id.0 {
@@ -28,7 +27,7 @@ impl DebugContext<'_> {
 
     pub(crate) fn debug_trait_id(
         &self,
-        id: super::TraitId,
+        id: chalk_db::TraitId,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         let trait_: hir_def::TraitId = from_chalk(self.0, id);
@@ -38,7 +37,7 @@ impl DebugContext<'_> {
 
     pub(crate) fn debug_assoc_type_id(
         &self,
-        id: super::AssocTypeId,
+        id: chalk_db::AssocTypeId,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         let type_alias: TypeAliasId = from_assoc_type_id(id);
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 1cda72d221..5f8666d902 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -9,20 +9,16 @@ use stdx::panic_context;
 
 use crate::{
     db::HirDatabase, AliasEq, AliasTy, Canonical, DomainGoal, Guidance, HirDisplay, InEnvironment,
-    Solution, TraitRefExt, Ty, TyKind, WhereClause,
+    Solution, TraitRefExt, Ty, TyKind, WhereClause, Interner,
 };
 
-use self::chalk::Interner;
-
-pub(crate) mod chalk;
-
 /// This controls how much 'time' we give the Chalk solver before giving up.
 const CHALK_SOLVER_FUEL: i32 = 100;
 
 #[derive(Debug, Copy, Clone)]
-struct ChalkContext<'a> {
-    db: &'a dyn HirDatabase,
-    krate: CrateId,
+pub(crate) struct ChalkContext<'a> {
+    pub(crate) db: &'a dyn HirDatabase,
+    pub(crate) krate: CrateId,
 }
 
 fn create_chalk_solver() -> chalk_recursive::RecursiveSolver<Interner> {
@@ -148,7 +144,7 @@ fn solve(
     // don't set the TLS for Chalk unless Chalk debugging is active, to make
     // extra sure we only use it for debugging
     let solution =
-        if is_chalk_debug() { chalk::tls::set_current_program(db, solve) } else { solve() };
+        if is_chalk_debug() { crate::tls::set_current_program(db, solve) } else { solve() };
 
     solution
 }

From 5ca481bbdc75bd3a9dbce4c94b014bd0eb8bd9e8 Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Fri, 9 Apr 2021 14:15:26 +0200
Subject: [PATCH 2/6] Move ToChalk -> mapping

---
 crates/hir_ty/src/chalk_db.rs   | 32 +++++++++++++++++---------------
 crates/hir_ty/src/db.rs         | 16 +++++++++++++---
 crates/hir_ty/src/display.rs    | 10 +++++-----
 crates/hir_ty/src/infer/expr.rs |  2 +-
 crates/hir_ty/src/interner.rs   | 17 +++++++++++++----
 crates/hir_ty/src/lib.rs        |  2 +-
 crates/hir_ty/src/lower.rs      |  8 ++++----
 crates/hir_ty/src/mapping.rs    | 20 ++++++++++++++++++--
 crates/hir_ty/src/tls.rs        |  4 +++-
 crates/hir_ty/src/traits.rs     |  2 +-
 10 files changed, 76 insertions(+), 37 deletions(-)

diff --git a/crates/hir_ty/src/chalk_db.rs b/crates/hir_ty/src/chalk_db.rs
index 566e4f406c..f5b2c5ff04 100644
--- a/crates/hir_ty/src/chalk_db.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -1,4 +1,5 @@
-//! Conversion code from/to Chalk.
+//! The implementation of `RustIrDatabase` for Chalk, which provides information
+//! about the code that Chalk needs.
 use std::sync::Arc;
 
 use log::debug;
@@ -13,7 +14,21 @@ use hir_def::{
 };
 use hir_expand::name::name;
 
-use crate::{AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause, traits::ChalkContext, db::HirDatabase, display::HirDisplay, from_assoc_type_id, make_only_type_binders, mapping::{convert_where_clauses, generic_predicate_to_inline_bound, TypeAliasAsValue}, method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS}, to_assoc_type_id, to_chalk_trait_id, utils::generics};
+use crate::{
+    db::HirDatabase,
+    display::HirDisplay,
+    from_assoc_type_id, make_only_type_binders,
+    mapping::{
+        convert_where_clauses, from_chalk, generic_predicate_to_inline_bound, ToChalk,
+        TypeAliasAsValue,
+    },
+    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
+    to_assoc_type_id, to_chalk_trait_id,
+    traits::ChalkContext,
+    utils::generics,
+    AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy,
+    Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
+};
 
 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
 pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
@@ -31,19 +46,6 @@ pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Inte
 pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
 pub(crate) type Variances = chalk_ir::Variances<Interner>;
 
-pub(crate) trait ToChalk {
-    type Chalk;
-    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
-    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
-}
-
-pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
-where
-    T: ToChalk<Chalk = ChalkT>,
-{
-    T::from_chalk(db, chalk)
-}
-
 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
     fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
         self.db.associated_ty_data(id)
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index ea0580df16..e11fc579e6 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -9,7 +9,12 @@ use hir_def::{
 };
 use la_arena::ArenaMap;
 
-use crate::{Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, Interner, PolyFnSig, QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db, method_resolution::{InherentImpls, TraitImpls}};
+use crate::{
+    chalk_db,
+    method_resolution::{InherentImpls, TraitImpls},
+    Binders, CallableDefId, FnDefId, ImplTraitId, InferenceResult, Interner, PolyFnSig,
+    QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
+};
 use hir_expand::name::Name;
 
 #[salsa::query_group(HirDatabaseStorage)]
@@ -93,10 +98,15 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;
 
     #[salsa::invoke(chalk_db::trait_datum_query)]
-    fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId) -> Arc<chalk_db::TraitDatum>;
+    fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId)
+        -> Arc<chalk_db::TraitDatum>;
 
     #[salsa::invoke(chalk_db::struct_datum_query)]
-    fn struct_datum(&self, krate: CrateId, struct_id: chalk_db::AdtId) -> Arc<chalk_db::StructDatum>;
+    fn struct_datum(
+        &self,
+        krate: CrateId,
+        struct_id: chalk_db::AdtId,
+    ) -> Arc<chalk_db::StructDatum>;
 
     #[salsa::invoke(chalk_db::impl_datum_query)]
     fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>;
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index a0746cd8fa..ae3a827808 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -20,11 +20,11 @@ use hir_expand::name::Name;
 
 use crate::{
     const_from_placeholder_idx, db::HirDatabase, from_assoc_type_id, from_foreign_def_id,
-    from_placeholder_idx, lt_from_placeholder_idx, primitive, subst_prefix, to_assoc_type_id,
-    chalk_db::from_chalk, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId,
-    CallableSig, Const, ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime,
-    LifetimeData, LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt,
-    QuantifiedWhereClause, Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
+    from_placeholder_idx, lt_from_placeholder_idx, mapping::from_chalk, primitive, subst_prefix,
+    to_assoc_type_id, utils::generics, AdtId, AliasEq, AliasTy, CallableDefId, CallableSig, Const,
+    ConstValue, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
+    LifetimeOutlives, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
+    Scalar, TraitRef, TraitRefExt, Ty, TyExt, TyKind, WhereClause,
 };
 
 pub struct HirFormatter<'a> {
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index d423830126..50497eecb0 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -17,11 +17,11 @@ use syntax::ast::RangeOp;
 use crate::{
     autoderef, dummy_usize_const,
     lower::lower_to_chalk_mutability,
+    mapping::from_chalk,
     method_resolution, op,
     primitive::{self, UintTy},
     static_lifetime, to_chalk_trait_id,
     traits::FnTrait,
-    chalk_db::from_chalk,
     utils::{generics, Generics},
     AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
     ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
diff --git a/crates/hir_ty/src/interner.rs b/crates/hir_ty/src/interner.rs
index 0187767cec..02e26c04ef 100644
--- a/crates/hir_ty/src/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -1,7 +1,7 @@
 //! Implementation of the Chalk `Interner` trait, which allows customizing the
 //! representation of the various objects Chalk deals with (types, goals etc.).
 
-use crate::{GenericArg, tls, chalk_db};
+use crate::{chalk_db, tls, GenericArg};
 use base_db::salsa::InternId;
 use chalk_ir::{Goal, GoalData};
 use hir_def::{
@@ -60,15 +60,24 @@ impl chalk_ir::interner::Interner for Interner {
     type Identifier = TypeAliasId;
     type FnAbi = ();
 
-    fn debug_adt_id(type_kind_id: chalk_db::AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_adt_id(
+        type_kind_id: chalk_db::AdtId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))
     }
 
-    fn debug_trait_id(type_kind_id: chalk_db::TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_trait_id(
+        type_kind_id: chalk_db::TraitId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt)))
     }
 
-    fn debug_assoc_type_id(id: chalk_db::AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+    fn debug_assoc_type_id(
+        id: chalk_db::AssocTypeId,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
     }
 
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 0743d3d30d..434e2e5333 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -51,13 +51,13 @@ pub use autoderef::autoderef;
 pub use builder::TyBuilder;
 pub use chalk_ext::*;
 pub use infer::{could_unify, InferenceResult};
+pub use interner::Interner;
 pub use lower::{
     associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
     TyDefId, TyLoweringContext, ValueTyDefId,
 };
 pub use traits::TraitEnvironment;
 pub use walk::TypeWalk;
-pub use interner::Interner;
 
 pub use chalk_ir::{
     cast::Cast, AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind,
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 0cdded3e1b..a035686bc9 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -27,14 +27,14 @@ use stdx::impl_from;
 
 use crate::{
     db::HirDatabase,
-    dummy_usize_const, static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
-    chalk_db::ToChalk,
-    Interner,
+    dummy_usize_const,
+    mapping::ToChalk,
+    static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
     utils::{
         all_super_trait_refs, associated_type_by_name_including_super_traits, generics, Generics,
     },
     AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, DynTy, FnPointer, FnSig,
-    FnSubst, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
+    FnSubst, ImplTraitId, Interner, OpaqueTy, PolyFnSig, ProjectionTy, QuantifiedWhereClause,
     QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits, Substitution,
     TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
 };
diff --git a/crates/hir_ty/src/mapping.rs b/crates/hir_ty/src/mapping.rs
index 4d3c41b2c4..f57115de6a 100644
--- a/crates/hir_ty/src/mapping.rs
+++ b/crates/hir_ty/src/mapping.rs
@@ -3,13 +3,29 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
 
-use chalk_ir::{DebruijnIndex, cast::Cast, fold::Shift};
+use chalk_ir::{cast::Cast, fold::Shift, DebruijnIndex};
 use chalk_solve::rust_ir;
 
 use base_db::salsa::InternKey;
 use hir_def::{GenericDefId, TypeAliasId};
 
-use crate::{AliasEq, AliasTy, CallableDefId, FnDefId, Interner, ProjectionTyExt, QuantifiedWhereClause, Substitution, Ty, WhereClause, chalk_db::{self, ToChalk}, db::HirDatabase};
+use crate::{
+    chalk_db, db::HirDatabase, AliasEq, AliasTy, CallableDefId, FnDefId, Interner, ProjectionTyExt,
+    QuantifiedWhereClause, Substitution, Ty, WhereClause,
+};
+
+pub(crate) trait ToChalk {
+    type Chalk;
+    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk;
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self;
+}
+
+pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T
+where
+    T: ToChalk<Chalk = ChalkT>,
+{
+    T::from_chalk(db, chalk)
+}
 
 impl ToChalk for hir_def::TraitId {
     type Chalk = chalk_db::TraitId;
diff --git a/crates/hir_ty/src/tls.rs b/crates/hir_ty/src/tls.rs
index c319bcf704..92989f11f6 100644
--- a/crates/hir_ty/src/tls.rs
+++ b/crates/hir_ty/src/tls.rs
@@ -4,7 +4,9 @@ use std::fmt;
 use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication};
 use itertools::Itertools;
 
-use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId, chalk_db::{from_chalk, self}, Interner};
+use crate::{
+    chalk_db, db::HirDatabase, from_assoc_type_id, mapping::from_chalk, CallableDefId, Interner,
+};
 use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
 
 pub(crate) use unsafe_tls::{set_current_program, with_current_program};
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 5f8666d902..7f77e421d4 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -9,7 +9,7 @@ use stdx::panic_context;
 
 use crate::{
     db::HirDatabase, AliasEq, AliasTy, Canonical, DomainGoal, Guidance, HirDisplay, InEnvironment,
-    Solution, TraitRefExt, Ty, TyKind, WhereClause, Interner,
+    Interner, Solution, TraitRefExt, Ty, TyKind, WhereClause,
 };
 
 /// This controls how much 'time' we give the Chalk solver before giving up.

From 9fba7cf827cf332800053eb26f10d67efeee7886 Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Fri, 9 Apr 2021 14:18:58 +0200
Subject: [PATCH 3/6] Move some more stuff to better places

---
 crates/hir_ty/src/chalk_db.rs | 99 +++++++++++++++++++++--------------
 crates/hir_ty/src/mapping.rs  | 92 +++++++++++---------------------
 2 files changed, 92 insertions(+), 99 deletions(-)

diff --git a/crates/hir_ty/src/chalk_db.rs b/crates/hir_ty/src/chalk_db.rs
index f5b2c5ff04..9d07ad597b 100644
--- a/crates/hir_ty/src/chalk_db.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -4,13 +4,13 @@ use std::sync::Arc;
 
 use log::debug;
 
-use chalk_ir::{fold::shift::Shift, CanonicalVarKinds};
+use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
 
-use base_db::{salsa::InternKey, CrateId};
+use base_db::CrateId;
 use hir_def::{
     lang_item::{lang_attr, LangItemTarget},
-    AssocContainerId, AssocItemId, HasModule, Lookup, TypeAliasId,
+    AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId,
 };
 use hir_expand::name::name;
 
@@ -18,16 +18,14 @@ use crate::{
     db::HirDatabase,
     display::HirDisplay,
     from_assoc_type_id, make_only_type_binders,
-    mapping::{
-        convert_where_clauses, from_chalk, generic_predicate_to_inline_bound, ToChalk,
-        TypeAliasAsValue,
-    },
+    mapping::{from_chalk, ToChalk, TypeAliasAsValue},
     method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
     to_assoc_type_id, to_chalk_trait_id,
     traits::ChalkContext,
     utils::generics,
     AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy,
-    Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
+    ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder,
+    TyExt, TyKind, WhereClause,
 };
 
 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
@@ -39,7 +37,6 @@ pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
 pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
-pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
 pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
 pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
 pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
@@ -679,38 +676,62 @@ pub(crate) fn adt_variance_query(
     )
 }
 
-impl From<FnDefId> for crate::db::InternedCallableDefId {
-    fn from(fn_def_id: FnDefId) -> Self {
-        InternKey::from_intern_id(fn_def_id.0)
+pub(super) fn convert_where_clauses(
+    db: &dyn HirDatabase,
+    def: GenericDefId,
+    substs: &Substitution,
+) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
+    let generic_predicates = db.generic_predicates(def);
+    let mut result = Vec::with_capacity(generic_predicates.len());
+    for pred in generic_predicates.iter() {
+        result.push(pred.clone().substitute(&Interner, substs));
     }
+    result
 }
 
-impl From<crate::db::InternedCallableDefId> for FnDefId {
-    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
-        chalk_ir::FnDefId(callable_def_id.as_intern_id())
-    }
-}
-
-impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
-    fn from(id: OpaqueTyId) -> Self {
-        InternKey::from_intern_id(id.0)
-    }
-}
-
-impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
-    fn from(id: crate::db::InternedOpaqueTyId) -> Self {
-        chalk_ir::OpaqueTyId(id.as_intern_id())
-    }
-}
-
-impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId {
-    fn from(id: chalk_ir::ClosureId<Interner>) -> Self {
-        Self::from_intern_id(id.0)
-    }
-}
-
-impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
-    fn from(id: crate::db::InternedClosureId) -> Self {
-        chalk_ir::ClosureId(id.as_intern_id())
+pub(super) fn generic_predicate_to_inline_bound(
+    db: &dyn HirDatabase,
+    pred: &QuantifiedWhereClause,
+    self_ty: &Ty,
+) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
+    // An InlineBound is like a GenericPredicate, except the self type is left out.
+    // We don't have a special type for this, but Chalk does.
+    let self_ty_shifted_in = self_ty.clone().shifted_in_from(&Interner, DebruijnIndex::ONE);
+    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
+    match pred {
+        WhereClause::Implemented(trait_ref) => {
+            if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in {
+                // we can only convert predicates back to type bounds if they
+                // have the expected self type
+                return None;
+            }
+            let args_no_self = trait_ref.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
+            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
+        }
+        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
+            if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in {
+                return None;
+            }
+            let trait_ = projection_ty.trait_(db);
+            let args_no_self = projection_ty.substitution.as_slice(&Interner)[1..]
+                .iter()
+                .map(|ty| ty.clone().cast(&Interner))
+                .collect();
+            let alias_eq_bound = rust_ir::AliasEqBound {
+                value: ty.clone(),
+                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self },
+                associated_ty_id: projection_ty.associated_ty_id,
+                parameters: Vec::new(), // FIXME we don't support generic associated types yet
+            };
+            Some(chalk_ir::Binders::new(
+                binders,
+                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
+            ))
+        }
+        _ => None,
     }
 }
diff --git a/crates/hir_ty/src/mapping.rs b/crates/hir_ty/src/mapping.rs
index f57115de6a..37c9351941 100644
--- a/crates/hir_ty/src/mapping.rs
+++ b/crates/hir_ty/src/mapping.rs
@@ -3,16 +3,12 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
 
-use chalk_ir::{cast::Cast, fold::Shift, DebruijnIndex};
 use chalk_solve::rust_ir;
 
 use base_db::salsa::InternKey;
-use hir_def::{GenericDefId, TypeAliasId};
+use hir_def::TypeAliasId;
 
-use crate::{
-    chalk_db, db::HirDatabase, AliasEq, AliasTy, CallableDefId, FnDefId, Interner, ProjectionTyExt,
-    QuantifiedWhereClause, Substitution, Ty, WhereClause,
-};
+use crate::{chalk_db, db::HirDatabase, CallableDefId, FnDefId, Interner, OpaqueTyId};
 
 pub(crate) trait ToChalk {
     type Chalk;
@@ -80,62 +76,38 @@ impl ToChalk for TypeAliasAsValue {
     }
 }
 
-pub(super) fn convert_where_clauses(
-    db: &dyn HirDatabase,
-    def: GenericDefId,
-    substs: &Substitution,
-) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
-    let generic_predicates = db.generic_predicates(def);
-    let mut result = Vec::with_capacity(generic_predicates.len());
-    for pred in generic_predicates.iter() {
-        result.push(pred.clone().substitute(&Interner, substs));
+impl From<FnDefId> for crate::db::InternedCallableDefId {
+    fn from(fn_def_id: FnDefId) -> Self {
+        InternKey::from_intern_id(fn_def_id.0)
     }
-    result
 }
 
-pub(super) fn generic_predicate_to_inline_bound(
-    db: &dyn HirDatabase,
-    pred: &QuantifiedWhereClause,
-    self_ty: &Ty,
-) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
-    // An InlineBound is like a GenericPredicate, except the self type is left out.
-    // We don't have a special type for this, but Chalk does.
-    let self_ty_shifted_in = self_ty.clone().shifted_in_from(&Interner, DebruijnIndex::ONE);
-    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
-    match pred {
-        WhereClause::Implemented(trait_ref) => {
-            if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in {
-                // we can only convert predicates back to type bounds if they
-                // have the expected self type
-                return None;
-            }
-            let args_no_self = trait_ref.substitution.as_slice(&Interner)[1..]
-                .iter()
-                .map(|ty| ty.clone().cast(&Interner))
-                .collect();
-            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
-            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
-        }
-        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in {
-                return None;
-            }
-            let trait_ = projection_ty.trait_(db);
-            let args_no_self = projection_ty.substitution.as_slice(&Interner)[1..]
-                .iter()
-                .map(|ty| ty.clone().cast(&Interner))
-                .collect();
-            let alias_eq_bound = rust_ir::AliasEqBound {
-                value: ty.clone(),
-                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self },
-                associated_ty_id: projection_ty.associated_ty_id,
-                parameters: Vec::new(), // FIXME we don't support generic associated types yet
-            };
-            Some(chalk_ir::Binders::new(
-                binders,
-                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
-            ))
-        }
-        _ => None,
+impl From<crate::db::InternedCallableDefId> for FnDefId {
+    fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self {
+        chalk_ir::FnDefId(callable_def_id.as_intern_id())
+    }
+}
+
+impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
+    fn from(id: OpaqueTyId) -> Self {
+        InternKey::from_intern_id(id.0)
+    }
+}
+
+impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId {
+    fn from(id: crate::db::InternedOpaqueTyId) -> Self {
+        chalk_ir::OpaqueTyId(id.as_intern_id())
+    }
+}
+
+impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId {
+    fn from(id: chalk_ir::ClosureId<Interner>) -> Self {
+        Self::from_intern_id(id.0)
+    }
+}
+
+impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
+    fn from(id: crate::db::InternedClosureId) -> Self {
+        chalk_ir::ClosureId(id.as_intern_id())
     }
 }

From 2f02977e56a44a5f78576a25547672cd8f910f13 Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Fri, 9 Apr 2021 14:28:04 +0200
Subject: [PATCH 4/6] More moving stuff around

---
 crates/hir_ty/src/chalk_db.rs | 15 +++++---
 crates/hir_ty/src/lib.rs      | 61 +++---------------------------
 crates/hir_ty/src/mapping.rs  | 71 +++++++++++++++++++++++++++--------
 crates/hir_ty/src/tls.rs      |  5 ++-
 4 files changed, 74 insertions(+), 78 deletions(-)

diff --git a/crates/hir_ty/src/chalk_db.rs b/crates/hir_ty/src/chalk_db.rs
index 9d07ad597b..8f054d06bf 100644
--- a/crates/hir_ty/src/chalk_db.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -17,7 +17,7 @@ use hir_expand::name::name;
 use crate::{
     db::HirDatabase,
     display::HirDisplay,
-    from_assoc_type_id, make_only_type_binders,
+    from_assoc_type_id, from_chalk_trait_id, make_only_type_binders,
     mapping::{from_chalk, ToChalk, TypeAliasAsValue},
     method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
     to_assoc_type_id, to_chalk_trait_id,
@@ -79,7 +79,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         binders: &CanonicalVarKinds<Interner>,
     ) -> Vec<ImplId> {
         debug!("impls_for_trait {:?}", trait_id);
-        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
+        let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
 
         let ty: Ty = parameters[0].assert_ty_ref(&Interner).clone();
 
@@ -161,7 +161,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
             Some(LangItemTarget::TraitId(trait_)) => trait_,
             _ => return None,
         };
-        Some(trait_.to_chalk(self.db))
+        Some(to_chalk_trait_id(trait_))
     }
 
     fn program_clauses_for_env(
@@ -308,7 +308,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
     }
 
     fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
-        let id = from_chalk(self.db, trait_id);
+        let id = from_chalk_trait_id(trait_id);
         self.db.trait_data(id).name.to_string()
     }
     fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
@@ -413,7 +413,7 @@ pub(crate) fn trait_datum_query(
     trait_id: TraitId,
 ) -> Arc<TraitDatum> {
     debug!("trait_datum {:?}", trait_id);
-    let trait_: hir_def::TraitId = from_chalk(db, trait_id);
+    let trait_ = from_chalk_trait_id(trait_id);
     let trait_data = db.trait_data(trait_);
     debug!("trait {:?} = {:?}", trait_id, trait_data.name);
     let generic_params = generics(db.upcast(), trait_.into());
@@ -723,7 +723,10 @@ pub(super) fn generic_predicate_to_inline_bound(
                 .collect();
             let alias_eq_bound = rust_ir::AliasEqBound {
                 value: ty.clone(),
-                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self },
+                trait_bound: rust_ir::TraitBound {
+                    trait_id: to_chalk_trait_id(trait_),
+                    args_no_self,
+                },
                 associated_ty_id: projection_ty.associated_ty_id,
                 parameters: Vec::new(), // FIXME we don't support generic associated types yet
             };
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 434e2e5333..6b5006f5dc 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -34,16 +34,12 @@ mod test_db;
 
 use std::sync::Arc;
 
-use base_db::salsa;
 use chalk_ir::{
     fold::{Fold, Shift},
     interner::HasInterner,
     UintTy,
 };
-use hir_def::{
-    expr::ExprId, type_ref::Rawness, ConstParamId, LifetimeParamId, TraitId, TypeAliasId,
-    TypeParamId,
-};
+use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
 
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
 
@@ -56,6 +52,11 @@ pub use lower::{
     associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
     TyDefId, TyLoweringContext, ValueTyDefId,
 };
+pub use mapping::{
+    const_from_placeholder_idx, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
+    to_foreign_def_id, to_placeholder_idx,
+};
 pub use traits::TraitEnvironment;
 pub use walk::TypeWalk;
 
@@ -242,56 +243,6 @@ pub(crate) struct ReturnTypeImplTrait {
     pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,
 }
 
-pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
-    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
-}
-
-pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-
-pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
-    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
-}
-
-pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-
-pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_type_param_id(interned_id)
-}
-
-pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
-    let interned_id = db.intern_type_param_id(id);
-    PlaceholderIndex {
-        ui: chalk_ir::UniverseIndex::ROOT,
-        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
-    }
-}
-
-pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_lifetime_param_id(interned_id)
-}
-
-pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
-    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
-    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
-    db.lookup_intern_const_param_id(interned_id)
-}
-
-pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
-    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
-}
-
-pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
-    salsa::InternKey::from_intern_id(id.0)
-}
-
 pub fn static_lifetime() -> Lifetime {
     LifetimeData::Static.intern(&Interner)
 }
diff --git a/crates/hir_ty/src/mapping.rs b/crates/hir_ty/src/mapping.rs
index 37c9351941..5e86fafe5d 100644
--- a/crates/hir_ty/src/mapping.rs
+++ b/crates/hir_ty/src/mapping.rs
@@ -5,10 +5,13 @@
 
 use chalk_solve::rust_ir;
 
-use base_db::salsa::InternKey;
-use hir_def::TypeAliasId;
+use base_db::salsa::{self, InternKey};
+use hir_def::{ConstParamId, LifetimeParamId, TraitId, TypeAliasId, TypeParamId};
 
-use crate::{chalk_db, db::HirDatabase, CallableDefId, FnDefId, Interner, OpaqueTyId};
+use crate::{
+    chalk_db, db::HirDatabase, AssocTypeId, CallableDefId, ChalkTraitId, FnDefId, ForeignDefId,
+    Interner, OpaqueTyId, PlaceholderIndex,
+};
 
 pub(crate) trait ToChalk {
     type Chalk;
@@ -23,18 +26,6 @@ where
     T::from_chalk(db, chalk)
 }
 
-impl ToChalk for hir_def::TraitId {
-    type Chalk = chalk_db::TraitId;
-
-    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::TraitId {
-        chalk_ir::TraitId(self.as_intern_id())
-    }
-
-    fn from_chalk(_db: &dyn HirDatabase, trait_id: chalk_db::TraitId) -> hir_def::TraitId {
-        InternKey::from_intern_id(trait_id.0)
-    }
-}
-
 impl ToChalk for hir_def::ImplId {
     type Chalk = chalk_db::ImplId;
 
@@ -111,3 +102,53 @@ impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
         chalk_ir::ClosureId(id.as_intern_id())
     }
 }
+
+pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {
+    chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))
+}
+
+pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+
+pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId {
+    chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id))
+}
+
+pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
+    salsa::InternKey::from_intern_id(id.0)
+}
+
+pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_type_param_id(interned_id)
+}
+
+pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex {
+    let interned_id = db.intern_type_param_id(id);
+    PlaceholderIndex {
+        ui: chalk_ir::UniverseIndex::ROOT,
+        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
+    }
+}
+
+pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_lifetime_param_id(interned_id)
+}
+
+pub fn const_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> ConstParamId {
+    assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
+    let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx));
+    db.lookup_intern_const_param_id(interned_id)
+}
+
+pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
+    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
+}
+
+pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
+    salsa::InternKey::from_intern_id(id.0)
+}
diff --git a/crates/hir_ty/src/tls.rs b/crates/hir_ty/src/tls.rs
index 92989f11f6..87c671a422 100644
--- a/crates/hir_ty/src/tls.rs
+++ b/crates/hir_ty/src/tls.rs
@@ -5,7 +5,8 @@ use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplicat
 use itertools::Itertools;
 
 use crate::{
-    chalk_db, db::HirDatabase, from_assoc_type_id, mapping::from_chalk, CallableDefId, Interner,
+    chalk_db, db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, mapping::from_chalk,
+    CallableDefId, Interner,
 };
 use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
 
@@ -32,7 +33,7 @@ impl DebugContext<'_> {
         id: chalk_db::TraitId,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
-        let trait_: hir_def::TraitId = from_chalk(self.0, id);
+        let trait_: hir_def::TraitId = from_chalk_trait_id(id);
         let trait_data = self.0.trait_data(trait_);
         write!(fmt, "{}", trait_data.name)
     }

From 8a2c4820821a9b266ed979ed9321431362cdb1b3 Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Fri, 9 Apr 2021 14:33:03 +0200
Subject: [PATCH 5/6] More cleanups

---
 crates/hir_ty/src/chalk_cast.rs | 16 ------------
 crates/hir_ty/src/interner.rs   |  9 +++++++
 crates/hir_ty/src/lib.rs        | 44 ++++++++++++++++-----------------
 3 files changed, 30 insertions(+), 39 deletions(-)
 delete mode 100644 crates/hir_ty/src/chalk_cast.rs

diff --git a/crates/hir_ty/src/chalk_cast.rs b/crates/hir_ty/src/chalk_cast.rs
deleted file mode 100644
index f27dee3fde..0000000000
--- a/crates/hir_ty/src/chalk_cast.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Implementations of the Chalk `Cast` trait for our types.
-
-use chalk_ir::interner::HasInterner;
-
-use crate::{CallableSig, ReturnTypeImplTraits};
-
-macro_rules! has_interner {
-    ($t:ty) => {
-        impl HasInterner for $t {
-            type Interner = crate::Interner;
-        }
-    };
-}
-
-has_interner!(CallableSig);
-has_interner!(ReturnTypeImplTraits);
diff --git a/crates/hir_ty/src/interner.rs b/crates/hir_ty/src/interner.rs
index 02e26c04ef..a1656115d6 100644
--- a/crates/hir_ty/src/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -412,3 +412,12 @@ impl chalk_ir::interner::Interner for Interner {
 impl chalk_ir::interner::HasInterner for Interner {
     type Interner = Self;
 }
+
+#[macro_export]
+macro_rules! has_interner {
+    ($t:ty) => {
+        impl HasInterner for $t {
+            type Interner = crate::Interner;
+        }
+    };
+}
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 6b5006f5dc..ef1bdefacb 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -7,25 +7,23 @@ macro_rules! eprintln {
 }
 
 mod autoderef;
-pub mod primitive;
-pub mod traits;
-pub mod method_resolution;
-mod op;
-mod lower;
-pub(crate) mod infer;
-pub(crate) mod utils;
-mod chalk_cast;
-mod chalk_ext;
 mod builder;
-mod walk;
-mod tls;
-mod interner;
-mod mapping;
 mod chalk_db;
-
-pub mod display;
+mod chalk_ext;
+mod infer;
+mod interner;
+mod lower;
+mod mapping;
+mod op;
+mod tls;
+mod utils;
+mod walk;
 pub mod db;
 pub mod diagnostics;
+pub mod display;
+pub mod method_resolution;
+pub mod primitive;
+pub mod traits;
 
 #[cfg(test)]
 mod tests;
@@ -100,6 +98,10 @@ pub type ConstValue = chalk_ir::ConstValue<Interner>;
 pub type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
 
 pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
+pub type TraitRef = chalk_ir::TraitRef<Interner>;
+pub type QuantifiedWhereClause = Binders<WhereClause>;
+pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
+pub type Canonical<T> = chalk_ir::Canonical<T>;
 
 pub type FnSig = chalk_ir::FnSig<Interner>;
 
@@ -159,14 +161,6 @@ pub fn make_canonical<T: HasInterner<Interner = Interner>>(
     Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
 }
 
-pub type TraitRef = chalk_ir::TraitRef<Interner>;
-
-pub type QuantifiedWhereClause = Binders<WhereClause>;
-
-pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
-
-pub type Canonical<T> = chalk_ir::Canonical<T>;
-
 /// A function signature as seen by type inference: Several parameter types and
 /// one return type.
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -175,6 +169,8 @@ pub struct CallableSig {
     is_varargs: bool,
 }
 
+has_interner!(CallableSig);
+
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<CallableSig>;
 
@@ -238,6 +234,8 @@ pub struct ReturnTypeImplTraits {
     pub(crate) impl_traits: Vec<ReturnTypeImplTrait>,
 }
 
+has_interner!(ReturnTypeImplTraits);
+
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
     pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,

From fbe98047d419ade6c87ccf432eb9534393d20020 Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Fri, 9 Apr 2021 14:39:07 +0200
Subject: [PATCH 6/6] More cleanups / module docs

---
 crates/hir_ty/src/db.rs          | 3 ++-
 crates/hir_ty/src/diagnostics.rs | 2 +-
 crates/hir_ty/src/display.rs     | 4 +++-
 crates/hir_ty/src/lib.rs         | 4 ++--
 crates/hir_ty/src/primitive.rs   | 5 +----
 crates/hir_ty/src/traits.rs      | 4 +++-
 6 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs
index e11fc579e6..1690926ad3 100644
--- a/crates/hir_ty/src/db.rs
+++ b/crates/hir_ty/src/db.rs
@@ -1,4 +1,5 @@
-//! FIXME: write short doc here
+//! The home of `HirDatabase`, which is the Salsa database containing all the
+//! type inference-related queries.
 
 use std::sync::Arc;
 
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 86f937e1d3..84fc8ce14d 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Type inference-based diagnostics.
 mod expr;
 mod match_check;
 mod unsafe_check;
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index ae3a827808..e7c9dabc22 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,4 +1,6 @@
-//! FIXME: write short doc here
+//! The `HirDisplay` trait, which serves two purposes: Turning various bits from
+//! HIR back into source code, and just displaying them for debugging/testing
+//! purposes.
 
 use std::{
     array,
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index ef1bdefacb..113234fa48 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -126,14 +126,14 @@ pub fn param_idx(db: &dyn HirDatabase, id: TypeParamId) -> Option<usize> {
     generics(db.upcast(), id.parent).param_idx(id)
 }
 
-pub fn wrap_empty_binders<T>(value: T) -> Binders<T>
+pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T>
 where
     T: Fold<Interner, Result = T> + HasInterner<Interner = Interner>,
 {
     Binders::empty(&Interner, value.shifted_in_from(&Interner, DebruijnIndex::ONE))
 }
 
-pub fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
+pub(crate) fn make_only_type_binders<T: HasInterner<Interner = Interner>>(
     num_vars: usize,
     value: T,
 ) -> Binders<T> {
diff --git a/crates/hir_ty/src/primitive.rs b/crates/hir_ty/src/primitive.rs
index 2449addfb7..d7f48c69a5 100644
--- a/crates/hir_ty/src/primitive.rs
+++ b/crates/hir_ty/src/primitive.rs
@@ -1,7 +1,4 @@
-//! Defines primitive types, which have a couple of peculiarities:
-//!
-//! * during type inference, they can be uncertain (ie, `let x = 92;`)
-//! * they don't belong to any particular crate.
+//! A few helper functions for dealing with primitives.
 
 pub use chalk_ir::{FloatTy, IntTy, UintTy};
 pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint};
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 7f77e421d4..9936d08033 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -1,9 +1,11 @@
 //! Trait solving using Chalk.
+
 use std::env::var;
 
-use base_db::CrateId;
 use chalk_ir::cast::Cast;
 use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
+
+use base_db::CrateId;
 use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;