70 files changed, 901 insertions, 723 deletions
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index f436bdbbf..d5bc4e574 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -56,12 +56,14 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
        ImportCandidate::QualifierStart(_) => {
            mark::hit!(qualify_path_qualifier_start);
            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
-            let segment = path.segment()?;
+            let (prev_segment, segment) = (path.qualifier()?.segment()?, path.segment()?);
-            QualifyCandidate::QualifierStart(segment)
+            QualifyCandidate::QualifierStart(segment, prev_segment.generic_arg_list())
        }
        ImportCandidate::UnqualifiedName(_) => {
            mark::hit!(qualify_path_unqualified_name);
-            QualifyCandidate::UnqualifiedName
+            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+            let generics = path.segment()?.generic_arg_list();
+            QualifyCandidate::UnqualifiedName(generics)
        }
        ImportCandidate::TraitAssocItem(_) => {
            mark::hit!(qualify_path_trait_assoc_item);
@@ -96,22 +98,25 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
 }
 enum QualifyCandidate<'db> {
-    QualifierStart(ast::PathSegment),
+    QualifierStart(ast::PathSegment, Option<ast::GenericArgList>),
-    UnqualifiedName,
+    UnqualifiedName(Option<ast::GenericArgList>),
    TraitAssocItem(ast::Path, ast::PathSegment),
    TraitMethod(&'db RootDatabase, ast::MethodCallExpr),
 }
 impl QualifyCandidate<'_> {
    fn qualify(&self, mut replacer: impl FnMut(String), import: hir::ModPath, item: hir::ItemInNs) {
+        let import = mod_path_to_ast(&import);
        match self {
-            QualifyCandidate::QualifierStart(segment) => {
+            QualifyCandidate::QualifierStart(segment, generics) => {
-                let import = mod_path_to_ast(&import);
+                let generics = generics.as_ref().map_or_else(String::new, ToString::to_string);
-                replacer(format!("{}::{}", import, segment));
+                replacer(format!("{}{}::{}", import, generics, segment));
+            }
+            QualifyCandidate::UnqualifiedName(generics) => {
+                let generics = generics.as_ref().map_or_else(String::new, ToString::to_string);
+                replacer(format!("{}{}", import.to_string(), generics));
            }
-            QualifyCandidate::UnqualifiedName => replacer(mod_path_to_ast(&import).to_string()),
            QualifyCandidate::TraitAssocItem(qualifier, segment) => {
-                let import = mod_path_to_ast(&import);
                replacer(format!("<{} as {}>::{}", qualifier, import, segment));
            }
            &QualifyCandidate::TraitMethod(db, ref mcall_expr) => {
@@ -124,25 +129,27 @@ impl QualifyCandidate<'_> {
        db: &RootDatabase,
        mcall_expr: &ast::MethodCallExpr,
        mut replacer: impl FnMut(String),
-        import: hir::ModPath,
+        import: ast::Path,
        item: hir::ItemInNs,
    ) -> Option<()> {
        let receiver = mcall_expr.receiver()?;
        let trait_method_name = mcall_expr.name_ref()?;
+        let generics =
+            mcall_expr.generic_arg_list().as_ref().map_or_else(String::new, ToString::to_string);
        let arg_list = mcall_expr.arg_list().map(|arg_list| arg_list.args());
        let trait_ = item_as_trait(item)?;
        let method = find_trait_method(db, trait_, &trait_method_name)?;
        if let Some(self_access) = method.self_param(db).map(|sp| sp.access(db)) {
-            let import = mod_path_to_ast(&import);
            let receiver = match self_access {
                hir::Access::Shared => make::expr_ref(receiver, false),
                hir::Access::Exclusive => make::expr_ref(receiver, true),
                hir::Access::Owned => receiver,
            };
            replacer(format!(
-                "{}::{}{}",
+                "{}::{}{}{}",
                import,
                trait_method_name,
+                generics,
                match arg_list.clone() {
                    Some(args) => make::arg_list(iter::once(receiver).chain(args)),
                    None => make::arg_list(iter::once(receiver)),
@@ -1045,4 +1052,153 @@ fn main() {
 ",
        );
    }
+    #[test]
+    fn keep_generic_annotations() {
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:dep
+pub mod generic { pub struct Thing<'a, T>(&'a T); }
+//- /main.rs crate:main deps:dep
+fn foo() -> Thin<|>g<'static, ()> {}
+fn main() {}
+",
+            r"
+fn foo() -> dep::generic::Thing<'static, ()> {}
+fn main() {}
+",
+        );
+    }
+    #[test]
+    fn keep_generic_annotations_leading_colon() {
+        check_assist(
+            qualify_path,
+            r"
+//- /lib.rs crate:dep
+pub mod generic { pub struct Thing<'a, T>(&'a T); }
+//- /main.rs crate:main deps:dep
+fn foo() -> Thin<|>g::<'static, ()> {}
+fn main() {}
+",
+            r"
+fn foo() -> dep::generic::Thing::<'static, ()> {}
+fn main() {}
+",
+        );
+    }
+    #[test]
+    fn associated_struct_const_generic() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub struct TestStruct<T> {}
+                impl<T> TestStruct<T> {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+            fn main() {
+                TestStruct::<()>::TEST_CONST<|>
+            }
+            ",
+            r"
+            mod test_mod {
+                pub struct TestStruct<T> {}
+                impl<T> TestStruct<T> {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+            fn main() {
+                test_mod::TestStruct::<()>::TEST_CONST
+            }
+            ",
+        );
+    }
+    #[test]
+    fn associated_trait_const_generic() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub struct TestStruct<T> {}
+                impl<T> TestTrait for TestStruct<T> {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+            fn main() {
+                test_mod::TestStruct::<()>::TEST_CONST<|>
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub struct TestStruct<T> {}
+                impl<T> TestTrait for TestStruct<T> {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+            fn main() {
+                <test_mod::TestStruct::<()> as test_mod::TestTrait>::TEST_CONST
+            }
+            ",
+        );
+    }
+    #[test]
+    fn trait_method_generic() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method<T>(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method<T>(&self) {}
+                }
+            }
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_struct.test_meth<|>od::<()>()
+            }
+            ",
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method<T>(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method<T>(&self) {}
+                }
+            }
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_mod::TestTrait::test_method::<()>(&test_struct)
+            }
+            ",
+        );
+    }
 }
diff --git a/crates/assists/src/utils/import_assets.rs b/crates/assists/src/utils/import_assets.rs
index 23db3a74b..f47edbb76 100644
--- a/crates/assists/src/utils/import_assets.rs
+++ b/crates/assists/src/utils/import_assets.rs
@@ -26,13 +26,13 @@ pub(crate) enum ImportCandidate {
 #[derive(Debug)]
 pub(crate) struct TraitImportCandidate {
-    pub ty: hir::Type,
+    pub(crate) ty: hir::Type,
-    pub name: ast::NameRef,
+    pub(crate) name: ast::NameRef,
 }
 #[derive(Debug)]
 pub(crate) struct PathImportCandidate {
-    pub name: ast::NameRef,
+    pub(crate) name: ast::NameRef,
 }
 #[derive(Debug)]
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/assists/src/utils/insert_use.rs
index 033fbcedc..a76bd5ebf 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/assists/src/utils/insert_use.rs
@@ -17,13 +17,13 @@ use syntax::{
 use test_utils::mark;
 #[derive(Debug)]
-pub enum ImportScope {
+pub(crate) enum ImportScope {
    File(ast::SourceFile),
    Module(ast::ItemList),
 }
 impl ImportScope {
-    pub fn from(syntax: SyntaxNode) -> Option<Self> {
+    pub(crate) fn from(syntax: SyntaxNode) -> Option<Self> {
        if let Some(module) = ast::Module::cast(syntax.clone()) {
            module.item_list().map(ImportScope::Module)
        } else if let this @ Some(_) = ast::SourceFile::cast(syntax.clone()) {
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 87f0a0ce5..31907ed98 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -12,9 +12,7 @@ use cfg::CfgOptions;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::SmolStr;
 use tt::TokenExpander;
-use vfs::{file_set::FileSet, VfsPath};
+use vfs::{file_set::FileSet, FileId, VfsPath};
-pub use vfs::FileId;
 /// Files are grouped into source roots. A source root is a directory on the
 /// file systems which is watched for changes. Typically it corresponds to a
diff --git a/crates/base_db/src/lib.rs b/crates/base_db/src/lib.rs
index 0804202d6..ce75a5337 100644
--- a/crates/base_db/src/lib.rs
+++ b/crates/base_db/src/lib.rs
@@ -14,11 +14,11 @@ pub use crate::{
    change::Change,
    input::{
        CrateData, CrateDisplayName, CrateGraph, CrateId, CrateName, Dependency, Edition, Env,
-        FileId, ProcMacroId, SourceRoot, SourceRootId,
+        ProcMacroId, SourceRoot, SourceRootId,
    },
 };
 pub use salsa;
-pub use vfs::{file_set::FileSet, VfsPath};
+pub use vfs::{file_set::FileSet, FileId, VfsPath};
 #[macro_export]
 macro_rules! impl_intern_key {
diff --git a/crates/completion/src/completions/postfix/format_like.rs b/crates/completion/src/completions/postfix/format_like.rs
index f35114ed1..88ba86acb 100644
--- a/crates/completion/src/completions/postfix/format_like.rs
+++ b/crates/completion/src/completions/postfix/format_like.rs
@@ -88,7 +88,7 @@ enum State {
 }
 impl FormatStrParser {
-    pub fn new(input: String) -> Self {
+    pub(crate) fn new(input: String) -> Self {
        Self {
            input: input.into(),
            output: String::new(),
@@ -98,7 +98,7 @@ impl FormatStrParser {
        }
    }
-    pub fn parse(&mut self) -> Result<(), ()> {
+    pub(crate) fn parse(&mut self) -> Result<(), ()> {
        let mut current_expr = String::new();
        let mut placeholder_id = 1;
@@ -194,7 +194,7 @@ impl FormatStrParser {
        Ok(())
    }
-    pub fn into_suggestion(&self, macro_name: &str) -> String {
+    pub(crate) fn into_suggestion(&self, macro_name: &str) -> String {
        assert!(self.parsed, "Attempt to get a suggestion from not parsed expression");
        let expressions_as_string = self.extracted_expressions.join(", ");
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 563145f92..30a5e4580 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -4,7 +4,6 @@ use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, Edition, FileId};
 use either::Either;
-use hir_def::find_path::PrefixKind;
 use hir_def::{
    adt::ReprKind,
    adt::StructKind,
@@ -12,16 +11,18 @@ use hir_def::{
    builtin_type::BuiltinType,
    expr::{BindingAnnotation, Pat, PatId},
    import_map,
+    item_tree::ItemTreeNode,
    lang_item::LangItemTarget,
    path::ModPath,
    per_ns::PerNs,
    resolver::{HasResolver, Resolver},
    src::HasSource as _,
    type_ref::{Mutability, TypeRef},
-    AdtId, AssocContainerId, AttrDefId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId,
+    AdtId, AssocContainerId, AssocItemId, AssocItemLoc, AttrDefId, ConstId, DefWithBodyId, EnumId,
-    HasModule, ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId,
+    FunctionId, GenericDefId, HasModule, ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId,
-    StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
 };
+use hir_def::{find_path::PrefixKind, item_scope::ItemInNs, visibility::Visibility};
 use hir_expand::{
    diagnostics::DiagnosticSink,
    name::{name, AsName},
@@ -275,11 +276,6 @@ impl ModuleDef {
    }
 }
-pub use hir_def::{
-    attr::Attrs, item_scope::ItemInNs, item_tree::ItemTreeNode, visibility::Visibility,
-    AssocItemId, AssocItemLoc,
-};
 impl Module {
    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
        Module { id: ModuleId { krate: krate.id, local_id: crate_module_id } }
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 033f53ac2..265ef6d1f 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -4,13 +4,13 @@
 //! are splitting the hir.
 use hir_def::{
-    expr::PatId, AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId,
+    expr::PatId, item_scope::ItemInNs, AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId,
-    ModuleDefId, VariantId,
+    GenericDefId, ModuleDefId, VariantId,
 };
 use crate::{
-    code_model::ItemInNs, Adt, AssocItem, DefWithBody, EnumVariant, Field, GenericDef, Local,
+    Adt, AssocItem, DefWithBody, EnumVariant, Field, GenericDef, Local, MacroDef, ModuleDef,
-    MacroDef, ModuleDef, VariantDef,
+    VariantDef,
 };
 macro_rules! from_id {
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 3bad2338a..c77494152 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -6,6 +6,7 @@ use hir_def::{
    src::{HasChildSource, HasSource as _},
    Lookup, VariantId,
 };
+use hir_expand::InFile;
 use syntax::ast;
 use crate::{
@@ -13,8 +14,6 @@ use crate::{
    Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
 };
-pub use hir_expand::InFile;
 pub trait HasSource {
    type Ast;
    fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast>;
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 4094a76cb..0d184379f 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -36,7 +36,7 @@ pub use crate::{
        Access, Adt, AsAssocItem, AssocItem, AssocItemContainer, Callable, CallableKind, Const,
        Crate, CrateDependency, DefWithBody, Enum, EnumVariant, Field, FieldSource, Function,
        GenericDef, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef, Static,
-        Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
+        Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
    },
    has_source::HasSource,
    semantics::{original_range, PathResolution, Semantics, SemanticsScope},
@@ -53,6 +53,7 @@ pub use hir_def::{
    nameres::ModuleSource,
    path::{ModPath, PathKind},
    type_ref::{Mutability, TypeRef},
+    visibility::Visibility,
 };
 pub use hir_expand::{
    name::known, name::AsName, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
diff --git a/crates/hir_def/src/body/diagnostics.rs b/crates/hir_def/src/body/diagnostics.rs
index cfa47d189..e57bdc133 100644
--- a/crates/hir_def/src/body/diagnostics.rs
+++ b/crates/hir_def/src/body/diagnostics.rs
@@ -5,12 +5,12 @@ use hir_expand::diagnostics::DiagnosticSink;
 use crate::diagnostics::InactiveCode;
 #[derive(Debug, Eq, PartialEq)]
-pub enum BodyDiagnostic {
+pub(crate) enum BodyDiagnostic {
    InactiveCode(InactiveCode),
 }
 impl BodyDiagnostic {
-    pub fn add_to(&self, sink: &mut DiagnosticSink<'_>) {
+    pub(crate) fn add_to(&self, sink: &mut DiagnosticSink<'_>) {
        match self {
            BodyDiagnostic::InactiveCode(diag) => {
                sink.push(diag.clone());
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index ddc267b83..1deaa90f2 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -45,14 +45,14 @@ pub(crate) struct LowerCtx {
 }
 impl LowerCtx {
-    pub fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
+    pub(crate) fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
        LowerCtx { hygiene: Hygiene::new(db.upcast(), file_id) }
    }
-    pub fn with_hygiene(hygiene: &Hygiene) -> Self {
+    pub(crate) fn with_hygiene(hygiene: &Hygiene) -> Self {
        LowerCtx { hygiene: hygiene.clone() }
    }
-    pub fn lower_path(&self, ast: ast::Path) -> Option<Path> {
+    pub(crate) fn lower_path(&self, ast: ast::Path) -> Option<Path> {
        Path::from_src(ast, &self.hygiene)
    }
 }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index f24a1dd77..1b22d1eec 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -486,12 +486,12 @@ impl AsMacroCall for InFile<&ast::MacroCall> {
 /// Helper wrapper for `AstId` with `ModPath`
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct AstIdWithPath<T: ast::AstNode> {
-    pub ast_id: AstId<T>,
+    ast_id: AstId<T>,
-    pub path: path::ModPath,
+    path: path::ModPath,
 }
 impl<T: ast::AstNode> AstIdWithPath<T> {
-    pub fn new(file_id: HirFileId, ast_id: FileAstId<T>, path: path::ModPath) -> AstIdWithPath<T> {
+    fn new(file_id: HirFileId, ast_id: FileAstId<T>, path: path::ModPath) -> AstIdWithPath<T> {
        AstIdWithPath { ast_id: AstId::new(file_id, ast_id), path }
    }
 }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 1ff45d244..59b6644c3 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -122,13 +122,13 @@ enum ImportSource {
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct Import {
-    pub path: ModPath,
+    path: ModPath,
-    pub alias: Option<ImportAlias>,
+    alias: Option<ImportAlias>,
-    pub visibility: RawVisibility,
+    visibility: RawVisibility,
-    pub is_glob: bool,
+    is_glob: bool,
-    pub is_prelude: bool,
+    is_prelude: bool,
-    pub is_extern_crate: bool,
+    is_extern_crate: bool,
-    pub is_macro_use: bool,
+    is_macro_use: bool,
    source: ImportSource,
 }
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 2b36c824a..00fe711fe 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -25,7 +25,7 @@ use crate::{db::DefDatabase, ModuleDefId};
    crate::db::DefDatabaseStorage
 )]
 #[derive(Default)]
-pub struct TestDB {
+pub(crate) struct TestDB {
    storage: salsa::Storage<TestDB>,
    events: Mutex<Option<Vec<salsa::Event>>>,
 }
@@ -72,7 +72,7 @@ impl FileLoader for TestDB {
 }
 impl TestDB {
-    pub fn module_for_file(&self, file_id: FileId) -> crate::ModuleId {
+    pub(crate) fn module_for_file(&self, file_id: FileId) -> crate::ModuleId {
        for &krate in self.relevant_crates(file_id).iter() {
            let crate_def_map = self.crate_def_map(krate);
            for (local_id, data) in crate_def_map.modules.iter() {
@@ -84,13 +84,13 @@ impl TestDB {
        panic!("Can't find module for file")
    }
-    pub fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
+    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
        *self.events.lock().unwrap() = Some(Vec::new());
        f();
        self.events.lock().unwrap().take().unwrap()
    }
-    pub fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
+    pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
        let events = self.log(f);
        events
            .into_iter()
@@ -105,7 +105,7 @@ impl TestDB {
            .collect()
    }
-    pub fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
+    pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
        let mut files = Vec::new();
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
@@ -129,7 +129,7 @@ impl TestDB {
            .collect()
    }
-    pub fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+    pub(crate) fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
            let crate_def_map = self.crate_def_map(krate);
@@ -148,7 +148,7 @@ impl TestDB {
        }
    }
-    pub fn check_diagnostics(&self) {
+    pub(crate) fn check_diagnostics(&self) {
        let db: &TestDB = self;
        let annotations = db.extract_annotations();
        assert!(!annotations.is_empty());
diff --git a/crates/hir_expand/src/test_db.rs b/crates/hir_expand/src/test_db.rs
index 86a5d867e..fca501e1f 100644
--- a/crates/hir_expand/src/test_db.rs
+++ b/crates/hir_expand/src/test_db.rs
@@ -14,7 +14,7 @@ use rustc_hash::FxHashSet;
    crate::db::AstDatabaseStorage
 )]
 #[derive(Default)]
-pub struct TestDB {
+pub(crate) struct TestDB {
    storage: salsa::Storage<TestDB>,
    events: Mutex<Option<Vec<salsa::Event>>>,
 }
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 367a1b98d..fdc65a5c3 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.34", default-features = false }
+chalk-solve = { version = "0.37", default-features = false }
-chalk-ir = "0.34"
+chalk-ir = "0.37"
-chalk-recursive = "0.34"
+chalk-recursive = "0.37"
 stdx = { path = "../stdx", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
index b0144a289..14e4d92f0 100644
--- a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
@@ -6,7 +6,7 @@
 /// Converts an identifier to an UpperCamelCase form.
 /// Returns `None` if the string is already is UpperCamelCase.
-pub fn to_camel_case(ident: &str) -> Option<String> {
+pub(crate) fn to_camel_case(ident: &str) -> Option<String> {
    if is_camel_case(ident) {
        return None;
    }
@@ -59,7 +59,7 @@ pub fn to_camel_case(ident: &str) -> Option<String> {
 /// Converts an identifier to a lower_snake_case form.
 /// Returns `None` if the string is already in lower_snake_case.
-pub fn to_lower_snake_case(ident: &str) -> Option<String> {
+pub(crate) fn to_lower_snake_case(ident: &str) -> Option<String> {
    if is_lower_snake_case(ident) {
        return None;
    } else if is_upper_snake_case(ident) {
@@ -71,7 +71,7 @@ pub fn to_lower_snake_case(ident: &str) -> Option<String> {
 /// Converts an identifier to an UPPER_SNAKE_CASE form.
 /// Returns `None` if the string is already is UPPER_SNAKE_CASE.
-pub fn to_upper_snake_case(ident: &str) -> Option<String> {
+pub(crate) fn to_upper_snake_case(ident: &str) -> Option<String> {
    if is_upper_snake_case(ident) {
        return None;
    } else if is_lower_snake_case(ident) {
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 278a4b947..434b19354 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -17,17 +17,10 @@ use crate::{
    ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
-pub use hir_def::{
+pub(crate) use hir_def::{
-    body::{
+    body::{Body, BodySourceMap},
-        scope::{ExprScopes, ScopeEntry, ScopeId},
+    expr::{Expr, ExprId, MatchArm, Pat, PatId},
-        Body, BodySourceMap, ExprPtr, ExprSource, PatPtr, PatSource,
+    LocalFieldId, VariantId,
-    },
-    expr::{
-        ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
-        MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
-    },
-    src::HasSource,
-    LocalFieldId, Lookup, VariantId,
 };
 pub(super) struct ExprValidator<'a, 'b: 'a> {
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 2da9688ca..6dc862826 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -59,12 +59,12 @@ impl<'a, 'b> UnsafeValidator<'a, 'b> {
    }
 }
-pub struct UnsafeExpr {
+pub(crate) struct UnsafeExpr {
-    pub expr: ExprId,
+    pub(crate) expr: ExprId,
-    pub inside_unsafe_block: bool,
+    pub(crate) inside_unsafe_block: bool,
 }
-pub fn unsafe_expressions(
+pub(crate) fn unsafe_expressions(
    db: &dyn HirDatabase,
    infer: &InferenceResult,
    def: DefWithBodyId,
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index d2e151f25..14e8c0633 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -26,6 +26,20 @@ pub trait HirDisplay {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError>;
    /// Returns a `Display`able type that is human-readable.
+    fn into_displayable<'a>(
+        &'a self,
+        db: &'a dyn HirDatabase,
+        max_size: Option<usize>,
+        omit_verbose_types: bool,
+        display_target: DisplayTarget,
+    ) -> HirDisplayWrapper<'a, Self>
+    where
+        Self: Sized,
+    {
+        HirDisplayWrapper { db, t: self, max_size, omit_verbose_types, display_target }
+    }
+    /// Returns a `Display`able type that is human-readable.
    /// Use this for showing types to the user (e.g. diagnostics)
    fn display<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self>
    where
@@ -82,6 +96,20 @@ pub trait HirDisplay {
        };
        Ok(result)
    }
+    /// Returns a String representation of `self` for test purposes
+    fn display_test<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self>
+    where
+        Self: Sized,
+    {
+        HirDisplayWrapper {
+            db,
+            t: self,
+            max_size: None,
+            omit_verbose_types: false,
+            display_target: DisplayTarget::Test,
+        }
+    }
 }
 impl<'a> HirFormatter<'a> {
@@ -126,7 +154,7 @@ impl<'a> HirFormatter<'a> {
 }
 #[derive(Clone, Copy)]
-enum DisplayTarget {
+pub enum DisplayTarget {
    /// Display types for inlays, doc popups, autocompletion, etc...
    /// Showing `{unknown}` or not qualifying paths is fine here.
    /// There's no reason for this to fail.
@@ -134,12 +162,17 @@ enum DisplayTarget {
    /// Display types for inserting them in source files.
    /// The generated code should compile, so paths need to be qualified.
    SourceCode { module_id: ModuleId },
+    /// Only for test purpose to keep real types
+    Test,
 }
 impl DisplayTarget {
    fn is_source_code(&self) -> bool {
        matches!(self, Self::SourceCode {..})
    }
+    fn is_test(&self) -> bool {
+        matches!(self, Self::Test)
+    }
 }
 #[derive(Debug)]
@@ -213,32 +246,32 @@ impl HirDisplay for ApplicationTy {
            TypeCtor::Str => write!(f, "str")?,
            TypeCtor::Slice => {
                let t = self.parameters.as_single();
-                write!(f, "[{}]", t.display(f.db))?;
+                write!(f, "[")?;
+                t.hir_fmt(f)?;
+                write!(f, "]")?;
            }
            TypeCtor::Array => {
                let t = self.parameters.as_single();
-                write!(f, "[{}; _]", t.display(f.db))?;
+                write!(f, "[")?;
+                t.hir_fmt(f)?;
+                write!(f, "; _]")?;
            }
            TypeCtor::RawPtr(m) => {
                let t = self.parameters.as_single();
-                let ty_display = t.display(f.db);
                write!(f, "*{}", m.as_keyword_for_ptr())?;
                if matches!(t, Ty::Dyn(predicates) if predicates.len() > 1) {
                    write!(f, "(")?;
-                    write!(f, "{}", ty_display)?;
+                    t.hir_fmt(f)?;
                    write!(f, ")")?;
                } else {
-                    write!(f, "{}", ty_display)?;
+                    t.hir_fmt(f)?;
                }
            }
            TypeCtor::Ref(m) => {
                let t = self.parameters.as_single();
-                let ty_display = if f.omit_verbose_types() {
+                let ty_display =
-                    t.display_truncated(f.db, f.max_size)
+                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
-                } else {
-                    t.display(f.db)
-                };
                write!(f, "&{}", m.as_keyword_for_ref())?;
                if matches!(t, Ty::Dyn(predicates) if predicates.len() > 1) {
@@ -253,7 +286,9 @@ impl HirDisplay for ApplicationTy {
            TypeCtor::Tuple { .. } => {
                let ts = &self.parameters;
                if ts.len() == 1 {
-                    write!(f, "({},)", ts[0].display(f.db))?;
+                    write!(f, "(")?;
+                    ts[0].hir_fmt(f)?;
+                    write!(f, ",)")?;
                } else {
                    write!(f, "(")?;
                    f.write_joined(&*ts.0, ", ")?;
@@ -274,11 +309,12 @@ impl HirDisplay for ApplicationTy {
                write!(f, ")")?;
                let ret = sig.ret();
                if *ret != Ty::unit() {
-                    let ret_display = if f.omit_verbose_types() {
+                    let ret_display = ret.into_displayable(
-                        ret.display_truncated(f.db, f.max_size)
+                        f.db,
-                    } else {
+                        f.max_size,
-                        ret.display(f.db)
+                        f.omit_verbose_types,
-                    };
+                        f.display_target,
+                    );
                    write!(f, " -> {}", ret_display)?;
                }
            }
@@ -310,17 +346,19 @@ impl HirDisplay for ApplicationTy {
                write!(f, ")")?;
                let ret = sig.ret();
                if *ret != Ty::unit() {
-                    let ret_display = if f.omit_verbose_types() {
+                    let ret_display = ret.into_displayable(
-                        ret.display_truncated(f.db, f.max_size)
+                        f.db,
-                    } else {
+                        f.max_size,
-                        ret.display(f.db)
+                        f.omit_verbose_types,
-                    };
+                        f.display_target,
+                    );
                    write!(f, " -> {}", ret_display)?;
                }
            }
            TypeCtor::Adt(def_id) => {
                match f.display_target {
-                    DisplayTarget::Diagnostics => {
+                    DisplayTarget::Diagnostics | DisplayTarget::Test => {
                        let name = match def_id {
                            AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
                            AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
@@ -389,12 +427,23 @@ impl HirDisplay for ApplicationTy {
                    _ => panic!("not an associated type"),
                };
                let trait_ = f.db.trait_data(trait_);
-                let type_alias = f.db.type_alias_data(type_alias);
+                let type_alias_data = f.db.type_alias_data(type_alias);
-                write!(f, "{}::{}", trait_.name, type_alias.name)?;
-                if self.parameters.len() > 0 {
+                // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)
-                    write!(f, "<")?;
+                if f.display_target.is_test() {
-                    f.write_joined(&*self.parameters.0, ", ")?;
+                    write!(f, "{}::{}", trait_.name, type_alias_data.name)?;
-                    write!(f, ">")?;
+                    if self.parameters.len() > 0 {
+                        write!(f, "<")?;
+                        f.write_joined(&*self.parameters.0, ", ")?;
+                        write!(f, ">")?;
+                    }
+                } else {
+                    let projection_ty = ProjectionTy {
+                        associated_ty: type_alias,
+                        parameters: self.parameters.clone(),
+                    };
+                    projection_ty.hir_fmt(f)?;
                }
            }
            TypeCtor::ForeignType(type_alias) => {
@@ -439,11 +488,12 @@ impl HirDisplay for ApplicationTy {
                        write!(f, "|")?;
                    };
-                    let ret_display = if f.omit_verbose_types() {
+                    let ret_display = sig.ret().into_displayable(
-                        sig.ret().display_truncated(f.db, f.max_size)
+                        f.db,
-                    } else {
+                        f.max_size,
-                        sig.ret().display(f.db)
+                        f.omit_verbose_types,
-                    };
+                        f.display_target,
+                    );
                    write!(f, " -> {}", ret_display)?;
                } else {
                    write!(f, "{{closure}}")?;
@@ -461,7 +511,13 @@ impl HirDisplay for ProjectionTy {
        }
        let trait_ = f.db.trait_data(self.trait_(f.db));
-        write!(f, "<{} as {}", self.parameters[0].display(f.db), trait_.name)?;
+        let first_parameter = self.parameters[0].into_displayable(
+            f.db,
+            f.max_size,
+            f.omit_verbose_types,
+            f.display_target,
+        );
+        write!(f, "<{} as {}", first_parameter, trait_.name)?;
        if self.parameters.len() > 1 {
            write!(f, "<")?;
            f.write_joined(&self.parameters[1..], ", ")?;
@@ -640,10 +696,10 @@ impl HirDisplay for GenericPredicate {
                projection_pred.projection_ty.trait_ref(f.db).hir_fmt_ext(f, true)?;
                write!(
                    f,
-                    ">::{} = {}",
+                    ">::{} = ",
                    f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name,
-                    projection_pred.ty.display(f.db)
                )?;
+                projection_pred.ty.hir_fmt(f)?;
            }
            GenericPredicate::Error => write!(f, "{{error}}")?,
        }
@@ -654,13 +710,18 @@ impl HirDisplay for GenericPredicate {
 impl HirDisplay for Obligation {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        match self {
-            Obligation::Trait(tr) => write!(f, "Implements({})", tr.display(f.db)),
+            Obligation::Trait(tr) => {
-            Obligation::Projection(proj) => write!(
+                write!(f, "Implements(")?;
-                f,
+                tr.hir_fmt(f)?;
-                "Normalize({} => {})",
+                write!(f, ")")
-                proj.projection_ty.display(f.db),
+            }
-                proj.ty.display(f.db)
+            Obligation::Projection(proj) => {
-            ),
+                write!(f, "Normalize(")?;
+                proj.projection_ty.hir_fmt(f)?;
+                write!(f, " => ")?;
+                proj.ty.hir_fmt(f)?;
+                write!(f, ")")
+            }
        }
    }
 }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 644ebd42d..a14d67c06 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -94,7 +94,7 @@ enum BindingMode {
 }
 impl BindingMode {
-    pub fn convert(annotation: BindingAnnotation) -> BindingMode {
+    fn convert(annotation: BindingAnnotation) -> BindingMode {
        match annotation {
            BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move,
            BindingAnnotation::Ref => BindingMode::Ref(Mutability::Shared),
@@ -214,9 +214,9 @@ struct InferenceContext<'a> {
 #[derive(Clone, Debug)]
 struct BreakableContext {
-    pub may_break: bool,
+    may_break: bool,
-    pub break_ty: Ty,
+    break_ty: Ty,
-    pub label: Option<name::Name>,
+    label: Option<name::Name>,
 }
 fn find_breakable<'c>(
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 8ac4cf89a..605951b10 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -107,7 +107,7 @@ impl<'a> InferenceContext<'a> {
        }
    }
-    pub fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+    pub(crate) fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
        match ty.callable_sig(self.db) {
            Some(sig) => Some((sig.params().to_vec(), sig.ret().clone())),
            None => self.callable_sig_from_fn_trait(ty, num_args),
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 2e895d911..76984242e 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -35,7 +35,7 @@ where
 #[derive(Debug)]
 pub(super) struct Canonicalized<T> {
-    pub value: Canonical<T>,
+    pub(super) value: Canonical<T>,
    free_vars: Vec<InferTy>,
 }
@@ -127,7 +127,7 @@ where
 }
 impl<T> Canonicalized<T> {
-    pub fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
+    pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
        ty.walk_mut_binders(
            &mut |ty, binders| {
                if let &mut Ty::Bound(bound) = ty {
@@ -141,7 +141,11 @@ impl<T> Canonicalized<T> {
        ty
    }
-    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Substs>) {
+    pub(super) fn apply_solution(
+        &self,
+        ctx: &mut InferenceContext<'_>,
+        solution: Canonical<Substs>,
+    ) {
        // the solution may contain new variables, which we need to convert to new inference vars
        let new_vars = Substs(
            solution
@@ -164,7 +168,7 @@ impl<T> Canonicalized<T> {
    }
 }
-pub fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
+pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
    let mut table = InferenceTable::new();
    let vars = Substs(
        tys.kinds
@@ -199,41 +203,46 @@ pub(crate) struct InferenceTable {
 }
 impl InferenceTable {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
        InferenceTable { var_unification_table: InPlaceUnificationTable::new() }
    }
-    pub fn new_type_var(&mut self) -> Ty {
+    pub(crate) fn new_type_var(&mut self) -> Ty {
        Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
    }
-    pub fn new_integer_var(&mut self) -> Ty {
+    pub(crate) fn new_integer_var(&mut self) -> Ty {
        Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
    }
-    pub fn new_float_var(&mut self) -> Ty {
+    pub(crate) fn new_float_var(&mut self) -> Ty {
        Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
    }
-    pub fn new_maybe_never_type_var(&mut self) -> Ty {
+    pub(crate) fn new_maybe_never_type_var(&mut self) -> Ty {
        Ty::Infer(InferTy::MaybeNeverTypeVar(
            self.var_unification_table.new_key(TypeVarValue::Unknown),
        ))
    }
-    pub fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
+    pub(crate) fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
        self.resolve_ty_completely_inner(&mut Vec::new(), ty)
    }
-    pub fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
+    pub(crate) fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
        self.resolve_ty_as_possible_inner(&mut Vec::new(), ty)
    }
-    pub fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
+    pub(crate) fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
        self.unify_inner(ty1, ty2, 0)
    }
-    pub fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs, depth: usize) -> bool {
+    pub(crate) fn unify_substs(
+        &mut self,
+        substs1: &Substs,
+        substs2: &Substs,
+        depth: usize,
+    ) -> bool {
        substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))
    }
@@ -331,7 +340,7 @@ impl InferenceTable {
    /// If `ty` is a type variable with known type, returns that type;
    /// otherwise, return ty.
-    pub fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> {
+    pub(crate) fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> {
        let mut ty = Cow::Borrowed(ty);
        // The type variable could resolve to a int/float variable. Hence try
        // resolving up to three times; each type of variable shouldn't occur
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 768d95eff..5a8c97198 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -1,6 +1,5 @@
 //! The type system. We currently use this to infer types for completion, hover
 //! information and various assists.
 #[allow(unused)]
 macro_rules! eprintln {
    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
@@ -1115,5 +1114,5 @@ pub struct ReturnTypeImplTraits {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub bounds: Binders<Vec<GenericPredicate>>,
+    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
 }
diff --git a/crates/hir_ty/src/test_db.rs b/crates/hir_ty/src/test_db.rs
index 15b8435e9..22254b765 100644
--- a/crates/hir_ty/src/test_db.rs
+++ b/crates/hir_ty/src/test_db.rs
@@ -21,7 +21,7 @@ use test_utils::extract_annotations;
    crate::db::HirDatabaseStorage
 )]
 #[derive(Default)]
-pub struct TestDB {
+pub(crate) struct TestDB {
    storage: salsa::Storage<TestDB>,
    events: Mutex<Option<Vec<salsa::Event>>>,
 }
@@ -113,13 +113,13 @@ impl TestDB {
 }
 impl TestDB {
-    pub fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
+    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
        *self.events.lock().unwrap() = Some(Vec::new());
        f();
        self.events.lock().unwrap().take().unwrap()
    }
-    pub fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
+    pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
        let events = self.log(f);
        events
            .into_iter()
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 0445efc9e..104ef334c 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -74,7 +74,7 @@ fn check_types_impl(ra_fixture: &str, display_source: bool) {
                let module = db.module_for_file(file_id);
                ty.display_source_code(&db, module).unwrap()
            } else {
-                ty.display(&db).to_string()
+                ty.display_test(&db).to_string()
            };
            assert_eq!(expected, actual);
            checked_one = true;
@@ -163,7 +163,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                macro_prefix,
                range,
                ellipsize(text, 15),
-                ty.display(&db)
+                ty.display_test(&db)
            );
        }
        if include_mismatches {
@@ -179,8 +179,8 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                    "{}{:?}: expected {}, got {}\n",
                    macro_prefix,
                    range,
-                    mismatch.expected.display(&db),
+                    mismatch.expected.display_test(&db),
-                    mismatch.actual.display(&db),
+                    mismatch.actual.display_test(&db),
                );
            }
        }
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index cbe5cd7dd..55e2c3a3e 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use log::debug;
-use chalk_ir::{fold::shift::Shift, CanonicalVarKinds, GenericArg, TypeName};
+use chalk_ir::{fold::shift::Shift, CanonicalVarKinds, GenericArg};
 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
 use base_db::{salsa::InternKey, CrateId};
@@ -27,7 +27,7 @@ use mapping::{
    TypeAliasAsValue,
 };
-pub use self::interner::*;
+pub(crate) use self::interner::*;
 pub(super) mod tls;
 mod interner;
@@ -81,7 +81,10 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref(&Interner).clone());
-        fn binder_kind(ty: &Ty, binders: &CanonicalVarKinds<Interner>) -> Option<chalk_ir::TyKind> {
+        fn binder_kind(
+            ty: &Ty,
+            binders: &CanonicalVarKinds<Interner>,
+        ) -> Option<chalk_ir::TyVariableKind> {
            if let Ty::Bound(bv) = ty {
                let binders = binders.as_slice(&Interner);
                if bv.debruijn == DebruijnIndex::INNERMOST {
@@ -95,8 +98,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        let self_ty_fp = TyFingerprint::for_impl(&ty);
        let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
-            Some(chalk_ir::TyKind::Integer) => &ALL_INT_FPS,
+            Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
-            Some(chalk_ir::TyKind::Float) => &ALL_FLOAT_FPS,
+            Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
            _ => self_ty_fp.as_ref().map(std::slice::from_ref).unwrap_or(&[]),
        };
@@ -129,12 +132,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        debug!("impls_for_trait returned {} impls", result.len());
        result
    }
-    fn impl_provided_for(
+    fn impl_provided_for(&self, auto_trait_id: TraitId, kind: &chalk_ir::TyKind<Interner>) -> bool {
-        &self,
+        debug!("impl_provided_for {:?}, {:?}", auto_trait_id, kind);
-        auto_trait_id: TraitId,
-        application_ty: &chalk_ir::ApplicationTy<Interner>,
-    ) -> bool {
-        debug!("impl_provided_for {:?}, {:?}", auto_trait_id, application_ty);
        false // FIXME
    }
    fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
@@ -466,7 +465,7 @@ pub(crate) fn struct_datum_query(
    struct_id: AdtId,
 ) -> Arc<StructDatum> {
    debug!("struct_datum {:?}", struct_id);
-    let type_ctor: TypeCtor = from_chalk(db, TypeName::Adt(struct_id));
+    let type_ctor = TypeCtor::Adt(from_chalk(db, struct_id));
    debug!("struct {:?} = {:?}", struct_id, type_ctor);
    let num_params = type_ctor.num_ty_params(db);
    let upstream = type_ctor.krate(db) != Some(krate);
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs
index f9304b7d0..39569e690 100644
--- a/crates/hir_ty/src/traits/chalk/interner.rs
+++ b/crates/hir_ty/src/traits/chalk/interner.rs
@@ -10,21 +10,21 @@ use std::{fmt, sync::Arc};
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
-pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
+pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
-pub type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
+pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
+pub(crate) type ForeignDefId = chalk_ir::ForeignDefId<Interner>;
-pub type TraitId = chalk_ir::TraitId<Interner>;
+pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
-pub type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
+pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-pub type AdtId = chalk_ir::AdtId<Interner>;
+pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
-pub type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
+pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub type ImplId = chalk_ir::ImplId<Interner>;
+pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
-pub type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-pub type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
+pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
-pub type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
+pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
-pub type FnDefId = chalk_ir::FnDefId<Interner>;
+pub(crate) type FnDefId = chalk_ir::FnDefId<Interner>;
-pub type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
+pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
-pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
+pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
-pub type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
+pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
 impl chalk_ir::interner::Interner for Interner {
    type InternedType = Arc<chalk_ir::TyData<Self>>;
@@ -122,13 +122,6 @@ impl chalk_ir::interner::Interner for Interner {
        tls::with_current_program(|prog| Some(prog?.debug_program_clause_implication(pci, fmt)))
    }
-    fn debug_application_ty(
-        application_ty: &chalk_ir::ApplicationTy<Interner>,
-        fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result> {
-        tls::with_current_program(|prog| Some(prog?.debug_application_ty(application_ty, fmt)))
-    }
    fn debug_substitution(
        substitution: &chalk_ir::Substitution<Interner>,
        fmt: &mut fmt::Formatter<'_>,
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index dd7affcec..86cbc4c7e 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -5,7 +5,7 @@
 use chalk_ir::{
    cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex, Scalar,
-    TypeName, UniverseIndex,
+    UniverseIndex,
 };
 use chalk_solve::rust_ir;
@@ -32,7 +32,7 @@ impl ToChalk for Ty {
                TypeCtor::Array => array_to_chalk(db, apply_ty.parameters),
                TypeCtor::FnPtr { num_args: _, is_varargs } => {
                    let substitution = apply_ty.parameters.to_chalk(db).shifted_in(&Interner);
-                    chalk_ir::TyData::Function(chalk_ir::FnPointer {
+                    chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                        num_binders: 0,
                        sig: chalk_ir::FnSig {
                            abi: (),
@@ -43,10 +43,68 @@ impl ToChalk for Ty {
                    })
                    .intern(&Interner)
                }
-                _ => {
+                TypeCtor::AssociatedType(type_alias) => {
-                    let name = apply_ty.ctor.to_chalk(db);
+                    let assoc_type = TypeAliasAsAssocType(type_alias);
+                    let assoc_type_id = assoc_type.to_chalk(db);
                    let substitution = apply_ty.parameters.to_chalk(db);
-                    chalk_ir::ApplicationTy { name, substitution }.cast(&Interner).intern(&Interner)
+                    chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner)
+                }
+                TypeCtor::OpaqueType(impl_trait_id) => {
+                    let id = impl_trait_id.to_chalk(db);
+                    let substitution = apply_ty.parameters.to_chalk(db);
+                    chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
+                }
+                TypeCtor::ForeignType(type_alias) => {
+                    let foreign_type = TypeAliasAsForeignType(type_alias);
+                    let foreign_type_id = foreign_type.to_chalk(db);
+                    chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner)
+                }
+                TypeCtor::Bool => chalk_ir::TyKind::Scalar(Scalar::Bool).intern(&Interner),
+                TypeCtor::Char => chalk_ir::TyKind::Scalar(Scalar::Char).intern(&Interner),
+                TypeCtor::Int(int_ty) => {
+                    chalk_ir::TyKind::Scalar(int_ty_to_chalk(int_ty)).intern(&Interner)
+                }
+                TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }) => {
+                    chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F32))
+                        .intern(&Interner)
+                }
+                TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }) => {
+                    chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64))
+                        .intern(&Interner)
+                }
+                TypeCtor::Tuple { cardinality } => {
+                    let substitution = apply_ty.parameters.to_chalk(db);
+                    chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
+                }
+                TypeCtor::RawPtr(mutability) => {
+                    let ty = apply_ty.parameters[0].clone().to_chalk(db);
+                    chalk_ir::TyKind::Raw(mutability.to_chalk(db), ty).intern(&Interner)
+                }
+                TypeCtor::Slice => {
+                    chalk_ir::TyKind::Slice(apply_ty.parameters[0].clone().to_chalk(db))
+                        .intern(&Interner)
+                }
+                TypeCtor::Str => chalk_ir::TyKind::Str.intern(&Interner),
+                TypeCtor::FnDef(callable_def) => {
+                    let id = callable_def.to_chalk(db);
+                    let substitution = apply_ty.parameters.to_chalk(db);
+                    chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner)
+                }
+                TypeCtor::Never => chalk_ir::TyKind::Never.intern(&Interner),
+                TypeCtor::Closure { def, expr } => {
+                    let closure_id = db.intern_closure((def, expr));
+                    let substitution = apply_ty.parameters.to_chalk(db);
+                    chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner)
+                }
+                TypeCtor::Adt(adt_id) => {
+                    let substitution = apply_ty.parameters.to_chalk(db);
+                    chalk_ir::TyKind::Adt(chalk_ir::AdtId(adt_id), substitution).intern(&Interner)
                }
            },
            Ty::Projection(proj_ty) => {
@@ -67,7 +125,7 @@ impl ToChalk for Ty {
                }
                .to_ty::<Interner>(&Interner)
            }
-            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx).intern(&Interner),
+            Ty::Bound(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
            Ty::Dyn(predicates) => {
                let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
@@ -78,55 +136,45 @@ impl ToChalk for Ty {
                    bounds: make_binders(where_clauses, 1),
                    lifetime: LifetimeData::Static.intern(&Interner),
                };
-                chalk_ir::TyData::Dyn(bounded_ty).intern(&Interner)
+                chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
            }
            Ty::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::TyData::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
+                chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
                    opaque_ty_id,
                    substitution,
                }))
                .intern(&Interner)
            }
-            Ty::Unknown => {
+            Ty::Unknown => chalk_ir::TyKind::Error.intern(&Interner),
-                let substitution = chalk_ir::Substitution::empty(&Interner);
-                let name = TypeName::Error;
-                chalk_ir::ApplicationTy { name, substitution }.cast(&Interner).intern(&Interner)
-            }
        }
    }
    fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
-        match chalk.data(&Interner).clone() {
+        match chalk.data(&Interner).kind.clone() {
-            chalk_ir::TyData::Apply(apply_ty) => match apply_ty.name {
+            chalk_ir::TyKind::Error => Ty::Unknown,
-                TypeName::Error => Ty::Unknown,
+            chalk_ir::TyKind::Array(ty, _size) => {
-                TypeName::Ref(m) => ref_from_chalk(db, m, apply_ty.substitution),
+                Ty::apply(TypeCtor::Array, Substs::single(from_chalk(db, ty)))
-                TypeName::Array => array_from_chalk(db, apply_ty.substitution),
+            }
-                _ => {
+            chalk_ir::TyKind::Placeholder(idx) => {
-                    let ctor = from_chalk(db, apply_ty.name);
-                    let parameters = from_chalk(db, apply_ty.substitution);
-                    Ty::Apply(ApplicationTy { ctor, parameters })
-                }
-            },
-            chalk_ir::TyData::Placeholder(idx) => {
                assert_eq!(idx.ui, UniverseIndex::ROOT);
                let interned_id = crate::db::GlobalTypeParamId::from_intern_id(
                    crate::salsa::InternId::from(idx.idx),
                );
                Ty::Placeholder(db.lookup_intern_type_param_id(interned_id))
            }
-            chalk_ir::TyData::Alias(chalk_ir::AliasTy::Projection(proj)) => {
+            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
                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 })
            }
-            chalk_ir::TyData::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
+            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 })
            }
-            chalk_ir::TyData::Function(chalk_ir::FnPointer {
+            chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                num_binders,
                sig: chalk_ir::FnSig { variadic, .. },
                substitution,
@@ -145,9 +193,9 @@ impl ToChalk for Ty {
                    parameters,
                })
            }
-            chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx),
+            chalk_ir::TyKind::BoundVar(idx) => Ty::Bound(idx),
-            chalk_ir::TyData::InferenceVar(_iv, _kind) => Ty::Unknown,
+            chalk_ir::TyKind::InferenceVar(_iv, _kind) => Ty::Unknown,
-            chalk_ir::TyData::Dyn(where_clauses) => {
+            chalk_ir::TyKind::Dyn(where_clauses) => {
                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
                let predicates = where_clauses
                    .bounds
@@ -157,10 +205,76 @@ impl ToChalk for Ty {
                    .collect();
                Ty::Dyn(predicates)
            }
+            chalk_ir::TyKind::Adt(struct_id, subst) => {
+                apply_ty_from_chalk(db, TypeCtor::Adt(struct_id.0), subst)
+            }
+            chalk_ir::TyKind::AssociatedType(type_id, subst) => apply_ty_from_chalk(
+                db,
+                TypeCtor::AssociatedType(from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0),
+                subst,
+            ),
+            chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => {
+                apply_ty_from_chalk(db, TypeCtor::OpaqueType(from_chalk(db, opaque_type_id)), subst)
+            }
+            chalk_ir::TyKind::Scalar(Scalar::Bool) => Ty::simple(TypeCtor::Bool),
+            chalk_ir::TyKind::Scalar(Scalar::Char) => Ty::simple(TypeCtor::Char),
+            chalk_ir::TyKind::Scalar(Scalar::Int(int_ty)) => Ty::simple(TypeCtor::Int(IntTy {
+                signedness: Signedness::Signed,
+                bitness: bitness_from_chalk_int(int_ty),
+            })),
+            chalk_ir::TyKind::Scalar(Scalar::Uint(uint_ty)) => Ty::simple(TypeCtor::Int(IntTy {
+                signedness: Signedness::Unsigned,
+                bitness: bitness_from_chalk_uint(uint_ty),
+            })),
+            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) => {
+                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }))
+            }
+            chalk_ir::TyKind::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => {
+                Ty::simple(TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }))
+            }
+            chalk_ir::TyKind::Tuple(cardinality, subst) => {
+                apply_ty_from_chalk(db, TypeCtor::Tuple { cardinality: cardinality as u16 }, subst)
+            }
+            chalk_ir::TyKind::Raw(mutability, ty) => {
+                Ty::apply_one(TypeCtor::RawPtr(from_chalk(db, mutability)), from_chalk(db, ty))
+            }
+            chalk_ir::TyKind::Slice(ty) => Ty::apply_one(TypeCtor::Slice, from_chalk(db, ty)),
+            chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
+                Ty::apply_one(TypeCtor::Ref(from_chalk(db, mutability)), from_chalk(db, ty))
+            }
+            chalk_ir::TyKind::Str => Ty::simple(TypeCtor::Str),
+            chalk_ir::TyKind::Never => Ty::simple(TypeCtor::Never),
+            chalk_ir::TyKind::FnDef(fn_def_id, subst) => {
+                let callable_def = from_chalk(db, fn_def_id);
+                apply_ty_from_chalk(db, TypeCtor::FnDef(callable_def), subst)
+            }
+            chalk_ir::TyKind::Closure(id, subst) => {
+                let id: crate::db::ClosureId = id.into();
+                let (def, expr) = db.lookup_intern_closure(id);
+                apply_ty_from_chalk(db, TypeCtor::Closure { def, expr }, subst)
+            }
+            chalk_ir::TyKind::Foreign(foreign_def_id) => Ty::simple(TypeCtor::ForeignType(
+                from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0,
+            )),
+            chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME
+            chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME
        }
    }
 }
+fn apply_ty_from_chalk(
+    db: &dyn HirDatabase,
+    ctor: TypeCtor,
+    subst: chalk_ir::Substitution<Interner>,
+) -> Ty {
+    Ty::Apply(ApplicationTy { ctor, parameters: from_chalk(db, subst) })
+}
 /// We currently don't model lifetimes, but Chalk does. So, we have to insert a
 /// fake lifetime here, because Chalks built-in logic may expect it to be there.
 fn ref_to_chalk(
@@ -170,60 +284,21 @@ fn ref_to_chalk(
 ) -> chalk_ir::Ty<Interner> {
    let arg = subst[0].clone().to_chalk(db);
    let lifetime = LifetimeData::Static.intern(&Interner);
-    chalk_ir::ApplicationTy {
+    chalk_ir::TyKind::Ref(mutability.to_chalk(db), lifetime, arg).intern(&Interner)
-        name: TypeName::Ref(mutability.to_chalk(db)),
-        substitution: chalk_ir::Substitution::from_iter(
-            &Interner,
-            vec![lifetime.cast(&Interner), arg.cast(&Interner)],
-        ),
-    }
-    .intern(&Interner)
-}
-/// Here we remove the lifetime from the type we got from Chalk.
-fn ref_from_chalk(
-    db: &dyn HirDatabase,
-    mutability: chalk_ir::Mutability,
-    subst: chalk_ir::Substitution<Interner>,
-) -> Ty {
-    let tys = subst
-        .iter(&Interner)
-        .filter_map(|p| Some(from_chalk(db, p.ty(&Interner)?.clone())))
-        .collect();
-    Ty::apply(TypeCtor::Ref(from_chalk(db, mutability)), Substs(tys))
 }
 /// We currently don't model constants, but Chalk does. So, we have to insert a
 /// fake constant here, because Chalks built-in logic may expect it to be there.
 fn array_to_chalk(db: &dyn HirDatabase, subst: Substs) -> chalk_ir::Ty<Interner> {
    let arg = subst[0].clone().to_chalk(db);
-    let usize_ty = chalk_ir::ApplicationTy {
+    let usize_ty =
-        name: TypeName::Scalar(Scalar::Uint(chalk_ir::UintTy::Usize)),
+        chalk_ir::TyKind::Scalar(Scalar::Uint(chalk_ir::UintTy::Usize)).intern(&Interner);
-        substitution: chalk_ir::Substitution::empty(&Interner),
-    }
-    .intern(&Interner);
    let const_ = chalk_ir::ConstData {
        ty: usize_ty,
        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
    }
    .intern(&Interner);
-    chalk_ir::ApplicationTy {
+    chalk_ir::TyKind::Array(arg, const_).intern(&Interner)
-        name: TypeName::Array,
-        substitution: chalk_ir::Substitution::from_iter(
-            &Interner,
-            vec![arg.cast(&Interner), const_.cast(&Interner)],
-        ),
-    }
-    .intern(&Interner)
-}
-/// Here we remove the const from the type we got from Chalk.
-fn array_from_chalk(db: &dyn HirDatabase, subst: chalk_ir::Substitution<Interner>) -> Ty {
-    let tys = subst
-        .iter(&Interner)
-        .filter_map(|p| Some(from_chalk(db, p.ty(&Interner)?.clone())))
-        .collect();
-    Ty::apply(TypeCtor::Array, Substs(tys))
 }
 impl ToChalk for Substs {
@@ -288,124 +363,6 @@ impl ToChalk for OpaqueTyId {
    }
 }
-impl ToChalk for TypeCtor {
-    type Chalk = TypeName<Interner>;
-    fn to_chalk(self, db: &dyn HirDatabase) -> TypeName<Interner> {
-        match self {
-            TypeCtor::AssociatedType(type_alias) => {
-                let assoc_type = TypeAliasAsAssocType(type_alias);
-                let assoc_type_id = assoc_type.to_chalk(db);
-                TypeName::AssociatedType(assoc_type_id)
-            }
-            TypeCtor::OpaqueType(impl_trait_id) => {
-                let id = impl_trait_id.to_chalk(db);
-                TypeName::OpaqueType(id)
-            }
-            TypeCtor::ForeignType(type_alias) => {
-                let foreign_type = TypeAliasAsForeignType(type_alias);
-                let foreign_type_id = foreign_type.to_chalk(db);
-                TypeName::Foreign(foreign_type_id)
-            }
-            TypeCtor::Bool => TypeName::Scalar(Scalar::Bool),
-            TypeCtor::Char => TypeName::Scalar(Scalar::Char),
-            TypeCtor::Int(int_ty) => TypeName::Scalar(int_ty_to_chalk(int_ty)),
-            TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 }) => {
-                TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F32))
-            }
-            TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 }) => {
-                TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F64))
-            }
-            TypeCtor::Tuple { cardinality } => TypeName::Tuple(cardinality.into()),
-            TypeCtor::RawPtr(mutability) => TypeName::Raw(mutability.to_chalk(db)),
-            TypeCtor::Slice => TypeName::Slice,
-            TypeCtor::Array => TypeName::Array,
-            TypeCtor::Ref(mutability) => TypeName::Ref(mutability.to_chalk(db)),
-            TypeCtor::Str => TypeName::Str,
-            TypeCtor::FnDef(callable_def) => {
-                let id = callable_def.to_chalk(db);
-                TypeName::FnDef(id)
-            }
-            TypeCtor::Never => TypeName::Never,
-            TypeCtor::Closure { def, expr } => {
-                let closure_id = db.intern_closure((def, expr));
-                TypeName::Closure(closure_id.into())
-            }
-            TypeCtor::Adt(adt_id) => TypeName::Adt(chalk_ir::AdtId(adt_id)),
-            TypeCtor::FnPtr { .. } => {
-                // This should not be reached, since Chalk doesn't represent
-                // function pointers with TypeName
-                unreachable!()
-            }
-        }
-    }
-    fn from_chalk(db: &dyn HirDatabase, type_name: TypeName<Interner>) -> TypeCtor {
-        match type_name {
-            TypeName::Adt(struct_id) => TypeCtor::Adt(struct_id.0),
-            TypeName::AssociatedType(type_id) => {
-                TypeCtor::AssociatedType(from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0)
-            }
-            TypeName::OpaqueType(opaque_type_id) => {
-                TypeCtor::OpaqueType(from_chalk(db, opaque_type_id))
-            }
-            TypeName::Scalar(Scalar::Bool) => TypeCtor::Bool,
-            TypeName::Scalar(Scalar::Char) => TypeCtor::Char,
-            TypeName::Scalar(Scalar::Int(int_ty)) => TypeCtor::Int(IntTy {
-                signedness: Signedness::Signed,
-                bitness: bitness_from_chalk_int(int_ty),
-            }),
-            TypeName::Scalar(Scalar::Uint(uint_ty)) => TypeCtor::Int(IntTy {
-                signedness: Signedness::Unsigned,
-                bitness: bitness_from_chalk_uint(uint_ty),
-            }),
-            TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) => {
-                TypeCtor::Float(FloatTy { bitness: FloatBitness::X32 })
-            }
-            TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => {
-                TypeCtor::Float(FloatTy { bitness: FloatBitness::X64 })
-            }
-            TypeName::Tuple(cardinality) => TypeCtor::Tuple { cardinality: cardinality as u16 },
-            TypeName::Raw(mutability) => TypeCtor::RawPtr(from_chalk(db, mutability)),
-            TypeName::Slice => TypeCtor::Slice,
-            TypeName::Ref(mutability) => TypeCtor::Ref(from_chalk(db, mutability)),
-            TypeName::Str => TypeCtor::Str,
-            TypeName::Never => TypeCtor::Never,
-            TypeName::FnDef(fn_def_id) => {
-                let callable_def = from_chalk(db, fn_def_id);
-                TypeCtor::FnDef(callable_def)
-            }
-            TypeName::Array => TypeCtor::Array,
-            TypeName::Closure(id) => {
-                let id: crate::db::ClosureId = id.into();
-                let (def, expr) = db.lookup_intern_closure(id);
-                TypeCtor::Closure { def, expr }
-            }
-            TypeName::Foreign(foreign_def_id) => {
-                TypeCtor::ForeignType(from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0)
-            }
-            TypeName::Error => {
-                // this should not be reached, since we don't represent TypeName::Error with TypeCtor
-                unreachable!()
-            }
-            TypeName::Generator(_) => unimplemented!(), // FIXME
-            TypeName::GeneratorWitness(_) => unimplemented!(), // FIXME
-        }
-    }
-}
 fn bitness_from_chalk_uint(uint_ty: chalk_ir::UintTy) -> IntBitness {
    use chalk_ir::UintTy;
@@ -507,7 +464,7 @@ impl ToChalk for CallableDefId {
    }
 }
-pub struct TypeAliasAsAssocType(pub TypeAliasId);
+pub(crate) struct TypeAliasAsAssocType(pub(crate) TypeAliasId);
 impl ToChalk for TypeAliasAsAssocType {
    type Chalk = AssocTypeId;
@@ -521,7 +478,7 @@ impl ToChalk for TypeAliasAsAssocType {
    }
 }
-pub struct TypeAliasAsForeignType(pub TypeAliasId);
+pub(crate) struct TypeAliasAsForeignType(pub(crate) TypeAliasId);
 impl ToChalk for TypeAliasAsForeignType {
    type Chalk = ForeignDefId;
@@ -535,7 +492,7 @@ impl ToChalk for TypeAliasAsForeignType {
    }
 }
-pub struct TypeAliasAsValue(pub TypeAliasId);
+pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
 impl ToChalk for TypeAliasAsValue {
    type Chalk = AssociatedTyValueId;
@@ -677,9 +634,9 @@ where
            .kinds
            .iter()
            .map(|k| match k {
-                TyKind::General => chalk_ir::TyKind::General,
+                TyKind::General => chalk_ir::TyVariableKind::General,
-                TyKind::Integer => chalk_ir::TyKind::Integer,
+                TyKind::Integer => chalk_ir::TyVariableKind::Integer,
-                TyKind::Float => chalk_ir::TyKind::Float,
+                TyKind::Float => chalk_ir::TyVariableKind::Float,
            })
            .map(|tk| {
                chalk_ir::CanonicalVarKind::new(
@@ -700,9 +657,9 @@ where
            .iter(&Interner)
            .map(|k| match k.kind {
                chalk_ir::VariableKind::Ty(tk) => match tk {
-                    chalk_ir::TyKind::General => TyKind::General,
+                    chalk_ir::TyVariableKind::General => TyKind::General,
-                    chalk_ir::TyKind::Integer => TyKind::Integer,
+                    chalk_ir::TyVariableKind::Integer => TyKind::Integer,
-                    chalk_ir::TyKind::Float => TyKind::Float,
+                    chalk_ir::TyVariableKind::Float => TyKind::Float,
                },
                chalk_ir::VariableKind::Lifetime => panic!("unexpected lifetime from Chalk"),
                chalk_ir::VariableKind::Const(_) => panic!("unexpected const from Chalk"),
@@ -768,7 +725,8 @@ where
    chalk_ir::Binders::new(
        chalk_ir::VariableKinds::from_iter(
            &Interner,
-            std::iter::repeat(chalk_ir::VariableKind::Ty(chalk_ir::TyKind::General)).take(num_vars),
+            std::iter::repeat(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General))
+                .take(num_vars),
        ),
        value,
    )
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs
index b4568cff6..75b16172e 100644
--- a/crates/hir_ty/src/traits/chalk/tls.rs
+++ b/crates/hir_ty/src/traits/chalk/tls.rs
@@ -1,114 +1,32 @@
 //! Implementation of Chalk debug helper functions using TLS.
 use std::fmt;
-use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication, TypeName};
+use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication};
 use itertools::Itertools;
 use super::{from_chalk, Interner, TypeAliasAsAssocType};
-use crate::{db::HirDatabase, CallableDefId, TypeCtor};
+use crate::{db::HirDatabase, CallableDefId};
-use hir_def::{AdtId, AssocContainerId, DefWithBodyId, Lookup, TypeAliasId};
+use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
-pub use unsafe_tls::{set_current_program, with_current_program};
+pub(crate) use unsafe_tls::{set_current_program, with_current_program};
-pub struct DebugContext<'a>(&'a dyn HirDatabase);
+pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase);
 impl DebugContext<'_> {
-    pub fn debug_struct_id(
+    pub(crate) fn debug_struct_id(
        &self,
        id: super::AdtId,
        f: &mut fmt::Formatter<'_>,
    ) -> Result<(), fmt::Error> {
-        let type_ctor: TypeCtor = from_chalk(self.0, TypeName::Adt(id));
+        let name = match id.0 {
-        match type_ctor {
+            AdtId::StructId(it) => self.0.struct_data(it).name.clone(),
-            TypeCtor::Bool => write!(f, "bool")?,
+            AdtId::UnionId(it) => self.0.union_data(it).name.clone(),
-            TypeCtor::Char => write!(f, "char")?,
+            AdtId::EnumId(it) => self.0.enum_data(it).name.clone(),
-            TypeCtor::Int(t) => write!(f, "{}", t)?,
+        };
-            TypeCtor::Float(t) => write!(f, "{}", t)?,
+        write!(f, "{}", name)
-            TypeCtor::Str => write!(f, "str")?,
-            TypeCtor::Slice => write!(f, "slice")?,
-            TypeCtor::Array => write!(f, "array")?,
-            TypeCtor::RawPtr(m) => write!(f, "*{}", m.as_keyword_for_ptr())?,
-            TypeCtor::Ref(m) => write!(f, "&{}", m.as_keyword_for_ref())?,
-            TypeCtor::Never => write!(f, "!")?,
-            TypeCtor::Tuple { .. } => {
-                write!(f, "()")?;
-            }
-            TypeCtor::FnPtr { .. } => {
-                write!(f, "fn")?;
-            }
-            TypeCtor::FnDef(def) => {
-                let name = match def {
-                    CallableDefId::FunctionId(ff) => self.0.function_data(ff).name.clone(),
-                    CallableDefId::StructId(s) => self.0.struct_data(s).name.clone(),
-                    CallableDefId::EnumVariantId(e) => {
-                        let enum_data = self.0.enum_data(e.parent);
-                        enum_data.variants[e.local_id].name.clone()
-                    }
-                };
-                match def {
-                    CallableDefId::FunctionId(_) => write!(f, "{{fn {}}}", name)?,
-                    CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {
-                        write!(f, "{{ctor {}}}", name)?
-                    }
-                }
-            }
-            TypeCtor::Adt(def_id) => {
-                let name = match def_id {
-                    AdtId::StructId(it) => self.0.struct_data(it).name.clone(),
-                    AdtId::UnionId(it) => self.0.union_data(it).name.clone(),
-                    AdtId::EnumId(it) => self.0.enum_data(it).name.clone(),
-                };
-                write!(f, "{}", name)?;
-            }
-            TypeCtor::AssociatedType(type_alias) => {
-                let trait_ = match type_alias.lookup(self.0.upcast()).container {
-                    AssocContainerId::TraitId(it) => it,
-                    _ => panic!("not an associated type"),
-                };
-                let trait_name = self.0.trait_data(trait_).name.clone();
-                let name = self.0.type_alias_data(type_alias).name.clone();
-                write!(f, "{}::{}", trait_name, name)?;
-            }
-            TypeCtor::OpaqueType(opaque_ty_id) => match opaque_ty_id {
-                crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
-                    write!(f, "{{impl trait {} of {:?}}}", idx, func)?;
-                }
-                crate::OpaqueTyId::AsyncBlockTypeImplTrait(def, idx) => {
-                    write!(f, "{{impl trait of async block {} of {:?}}}", idx.into_raw(), def)?;
-                }
-            },
-            TypeCtor::ForeignType(type_alias) => {
-                let name = self.0.type_alias_data(type_alias).name.clone();
-                write!(f, "{}", name)?;
-            }
-            TypeCtor::Closure { def, expr } => {
-                write!(f, "{{closure {:?} in ", expr.into_raw())?;
-                match def {
-                    DefWithBodyId::FunctionId(func) => {
-                        write!(f, "fn {}", self.0.function_data(func).name)?
-                    }
-                    DefWithBodyId::StaticId(s) => {
-                        if let Some(name) = self.0.static_data(s).name.as_ref() {
-                            write!(f, "body of static {}", name)?;
-                        } else {
-                            write!(f, "body of unnamed static {:?}", s)?;
-                        }
-                    }
-                    DefWithBodyId::ConstId(c) => {
-                        if let Some(name) = self.0.const_data(c).name.as_ref() {
-                            write!(f, "body of const {}", name)?;
-                        } else {
-                            write!(f, "body of unnamed const {:?}", c)?;
-                        }
-                    }
-                };
-                write!(f, "}}")?;
-            }
-        }
-        Ok(())
    }
-    pub fn debug_trait_id(
+    pub(crate) fn debug_trait_id(
        &self,
        id: super::TraitId,
        fmt: &mut fmt::Formatter<'_>,
@@ -118,7 +36,7 @@ impl DebugContext<'_> {
        write!(fmt, "{}", trait_data.name)
    }
-    pub fn debug_assoc_type_id(
+    pub(crate) fn debug_assoc_type_id(
        &self,
        id: super::AssocTypeId,
        fmt: &mut fmt::Formatter<'_>,
@@ -133,7 +51,7 @@ impl DebugContext<'_> {
        write!(fmt, "{}::{}", trait_data.name, type_alias_data.name)
    }
-    pub fn debug_opaque_ty_id(
+    pub(crate) fn debug_opaque_ty_id(
        &self,
        opaque_ty_id: chalk_ir::OpaqueTyId<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -141,7 +59,7 @@ impl DebugContext<'_> {
        fmt.debug_struct("OpaqueTyId").field("index", &opaque_ty_id.0).finish()
    }
-    pub fn debug_alias(
+    pub(crate) fn debug_alias(
        &self,
        alias_ty: &AliasTy<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -152,7 +70,7 @@ impl DebugContext<'_> {
        }
    }
-    pub fn debug_projection_ty(
+    pub(crate) fn debug_projection_ty(
        &self,
        projection_ty: &chalk_ir::ProjectionTy<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -177,7 +95,7 @@ impl DebugContext<'_> {
        write!(fmt, ">::{}", type_alias_data.name)
    }
-    pub fn debug_opaque_ty(
+    pub(crate) fn debug_opaque_ty(
        &self,
        opaque_ty: &chalk_ir::OpaqueTy<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -185,7 +103,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", opaque_ty.opaque_ty_id)
    }
-    pub fn debug_ty(
+    pub(crate) fn debug_ty(
        &self,
        ty: &chalk_ir::Ty<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -193,7 +111,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", ty.data(&Interner))
    }
-    pub fn debug_lifetime(
+    pub(crate) fn debug_lifetime(
        &self,
        lifetime: &Lifetime<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -201,7 +119,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", lifetime.data(&Interner))
    }
-    pub fn debug_generic_arg(
+    pub(crate) fn debug_generic_arg(
        &self,
        parameter: &GenericArg<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -209,7 +127,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", parameter.data(&Interner).inner_debug())
    }
-    pub fn debug_goal(
+    pub(crate) fn debug_goal(
        &self,
        goal: &Goal<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -218,7 +136,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", goal_data)
    }
-    pub fn debug_goals(
+    pub(crate) fn debug_goals(
        &self,
        goals: &Goals<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -226,7 +144,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", goals.debug(&Interner))
    }
-    pub fn debug_program_clause_implication(
+    pub(crate) fn debug_program_clause_implication(
        &self,
        pci: &ProgramClauseImplication<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -234,15 +152,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", pci.debug(&Interner))
    }
-    pub fn debug_application_ty(
+    pub(crate) fn debug_substitution(
-        &self,
-        application_ty: &chalk_ir::ApplicationTy<Interner>,
-        fmt: &mut fmt::Formatter<'_>,
-    ) -> Result<(), fmt::Error> {
-        write!(fmt, "{:?}", application_ty.debug(&Interner))
-    }
-    pub fn debug_substitution(
        &self,
        substitution: &chalk_ir::Substitution<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -250,7 +160,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", substitution.debug(&Interner))
    }
-    pub fn debug_separator_trait_ref(
+    pub(crate) fn debug_separator_trait_ref(
        &self,
        separator_trait_ref: &chalk_ir::SeparatorTraitRef<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -258,7 +168,7 @@ impl DebugContext<'_> {
        write!(fmt, "{:?}", separator_trait_ref.debug(&Interner))
    }
-    pub fn debug_fn_def_id(
+    pub(crate) fn debug_fn_def_id(
        &self,
        fn_def_id: chalk_ir::FnDefId<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -280,7 +190,7 @@ impl DebugContext<'_> {
        }
    }
-    pub fn debug_const(
+    pub(crate) fn debug_const(
        &self,
        _constant: &chalk_ir::Const<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -288,42 +198,42 @@ impl DebugContext<'_> {
        write!(fmt, "const")
    }
-    pub fn debug_variable_kinds(
+    pub(crate) fn debug_variable_kinds(
        &self,
        variable_kinds: &chalk_ir::VariableKinds<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        write!(fmt, "{:?}", variable_kinds.as_slice(&Interner))
    }
-    pub fn debug_variable_kinds_with_angles(
+    pub(crate) fn debug_variable_kinds_with_angles(
        &self,
        variable_kinds: &chalk_ir::VariableKinds<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        write!(fmt, "{:?}", variable_kinds.inner_debug(&Interner))
    }
-    pub fn debug_canonical_var_kinds(
+    pub(crate) fn debug_canonical_var_kinds(
        &self,
        canonical_var_kinds: &chalk_ir::CanonicalVarKinds<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        write!(fmt, "{:?}", canonical_var_kinds.as_slice(&Interner))
    }
-    pub fn debug_program_clause(
+    pub(crate) fn debug_program_clause(
        &self,
        clause: &chalk_ir::ProgramClause<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        write!(fmt, "{:?}", clause.data(&Interner))
    }
-    pub fn debug_program_clauses(
+    pub(crate) fn debug_program_clauses(
        &self,
        clauses: &chalk_ir::ProgramClauses<Interner>,
        fmt: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        write!(fmt, "{:?}", clauses.as_slice(&Interner))
    }
-    pub fn debug_quantified_where_clauses(
+    pub(crate) fn debug_quantified_where_clauses(
        &self,
        clauses: &chalk_ir::QuantifiedWhereClauses<Interner>,
        fmt: &mut fmt::Formatter<'_>,
@@ -339,7 +249,7 @@ mod unsafe_tls {
    scoped_thread_local!(static PROGRAM: DebugContext);
-    pub fn with_current_program<R>(
+    pub(crate) fn with_current_program<R>(
        op: impl for<'a> FnOnce(Option<&'a DebugContext<'a>>) -> R,
    ) -> R {
        if PROGRAM.is_set() {
@@ -349,7 +259,7 @@ mod unsafe_tls {
        }
    }
-    pub fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R
+    pub(crate) fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R
    where
        OP: FnOnce() -> R,
    {
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 0c950003e..02e17ba43 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -25,7 +25,7 @@ use crate::{diagnostics::Fix, references::rename::rename_with_semantics, FilePos
 /// A [Diagnostic] that potentially has a fix available.
 ///
 /// [Diagnostic]: hir::diagnostics::Diagnostic
-pub trait DiagnosticWithFix: Diagnostic {
+pub(crate) trait DiagnosticWithFix: Diagnostic {
    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix>;
 }
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 250f10f9f..10263537a 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -1,7 +1,6 @@
 //! Resolves and rewrites links in markdown documentation.
-use std::convert::TryFrom;
+use std::{convert::TryFrom, iter::once};
-use std::iter::once;
 use itertools::Itertools;
 use pulldown_cmark::{BrokenLink, CowStr, Event, InlineStr, LinkType, Options, Parser, Tag};
@@ -21,10 +20,10 @@ use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset,
 use crate::{FilePosition, Semantics};
-pub type DocumentationLink = String;
+pub(crate) type DocumentationLink = String;
 /// Rewrite documentation links in markdown to point to an online host (e.g. docs.rs)
-pub fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Definition) -> String {
+pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Definition) -> String {
    let mut cb = |link: BrokenLink| {
        Some((
            /*url*/ link.reference.to_owned().into(),
@@ -63,7 +62,7 @@ pub fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Definition)
 }
 /// Remove all links in markdown documentation.
-pub fn remove_links(markdown: &str) -> String {
+pub(crate) fn remove_links(markdown: &str) -> String {
    let mut drop_link = false;
    let mut opts = Options::empty();
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index 6168fb837..415795e8c 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -27,7 +27,7 @@ pub struct StructureNode {
 //
 // | VS Code | kbd:[Ctrl+Shift+O]
 // |===
-pub fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
+pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
    let mut res = Vec::new();
    let mut stack = Vec::new();
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index b6113bda2..ac704ae21 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -1339,4 +1339,25 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn infer_call_method_return_associated_types_with_generic() {
+        check(
+            r#"
+            pub trait Default {
+                fn default() -> Self;
+            }
+            pub trait Foo {
+                type Bar: Default;
+            }
+            pub fn quux<T: Foo>() -> T::Bar {
+                let y = Default::default();
+                  //^ <T as Foo>::Bar
+                y
+            }
+            "#,
+        );
+    }
 }
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index e37702acd..b5a6f66fd 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -18,7 +18,7 @@ use text_edit::{TextEdit, TextEditBuilder};
 //
 // | VS Code | **Rust Analyzer: Join lines**
 // |===
-pub fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
+pub(crate) fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
    let range = if range.is_empty() {
        let syntax = file.syntax();
        let text = syntax.text().slice(range.start()..);
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 4bc733b70..6288f7ea7 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -72,18 +72,20 @@ pub use crate::{
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    markup::Markup,
    prime_caches::PrimeCachesProgress,
-    references::{
+    references::{rename::RenameError, Declaration, ReferenceSearchResult},
-        Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult, RenameError,
-    },
    runnables::{Runnable, RunnableKind, TestId},
    syntax_highlighting::{
-        Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
+        tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag},
+        HighlightedRange,
    },
 };
 pub use completion::{
    CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
 };
-pub use ide_db::call_info::CallInfo;
+pub use ide_db::{
+    call_info::CallInfo,
+    search::{Reference, ReferenceAccess, ReferenceKind},
+};
 pub use assists::{
    utils::MergeBehaviour, Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist,
@@ -503,7 +505,7 @@ impl Analysis {
        position: FilePosition,
        new_name: &str,
    ) -> Cancelable<Result<RangeInfo<SourceChange>, RenameError>> {
-        self.with_db(|db| references::rename(db, position, new_name))
+        self.with_db(|db| references::rename::rename(db, position, new_name))
    }
    pub fn structural_search_replace(
diff --git a/crates/ide/src/markdown_remove.rs b/crates/ide/src/markdown_remove.rs
index 02ad39dfb..3ec5c629e 100644
--- a/crates/ide/src/markdown_remove.rs
+++ b/crates/ide/src/markdown_remove.rs
@@ -1,11 +1,10 @@
 //! Removes markdown from strings.
 use pulldown_cmark::{Event, Parser, Tag};
 /// Removes all markdown, keeping the text and code blocks
 ///
 /// Currently limited in styling, i.e. no ascii tables or lists
-pub fn remove_markdown(markdown: &str) -> String {
+pub(crate) fn remove_markdown(markdown: &str) -> String {
    let mut out = String::new();
    let parser = Parser::new(markdown);
diff --git a/crates/ide/src/matching_brace.rs b/crates/ide/src/matching_brace.rs
index cb6abb0db..d70248afe 100644
--- a/crates/ide/src/matching_brace.rs
+++ b/crates/ide/src/matching_brace.rs
@@ -15,7 +15,7 @@ use test_utils::mark;
 //
 // | VS Code | **Rust Analyzer: Find matching brace**
 // |===
-pub fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<TextSize> {
+pub(crate) fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<TextSize> {
    const BRACES: &[SyntaxKind] =
        &[T!['{'], T!['}'], T!['['], T![']'], T!['('], T![')'], T![<], T![>], T![|], T![|]];
    let (brace_token, brace_idx) = file
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index a517081d5..e05465b32 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -14,7 +14,8 @@ pub(crate) mod rename;
 use hir::Semantics;
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
-    search::SearchScope,
+    search::Reference,
+    search::{ReferenceAccess, ReferenceKind, SearchScope},
    RootDatabase,
 };
 use syntax::{
@@ -25,11 +26,6 @@ use syntax::{
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
-pub(crate) use self::rename::rename;
-pub use self::rename::RenameError;
-pub use ide_db::search::{Reference, ReferenceAccess, ReferenceKind};
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
    declaration: Declaration,
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index eb82456ad..2bd0e86e5 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -102,6 +102,7 @@ pub(crate) fn runnable(
 ) -> Option<Runnable> {
    match_ast! {
        match item {
+            ast::Struct(it) => runnable_struct(sema, it, file_id),
            ast::Fn(it) => runnable_fn(sema, it, file_id),
            ast::Module(it) => runnable_mod(sema, it, file_id),
            _ => None,
@@ -182,6 +183,43 @@ fn runnable_fn(
    Some(Runnable { nav, kind, cfg })
 }
+fn runnable_struct(
+    sema: &Semantics<RootDatabase>,
+    struct_def: ast::Struct,
+    file_id: FileId,
+) -> Option<Runnable> {
+    if !has_runnable_doc_test(&struct_def) {
+        return None;
+    }
+    let name_string = struct_def.name()?.text().to_string();
+    let attrs =
+        Attrs::from_attrs_owner(sema.db, InFile::new(HirFileId::from(file_id), &struct_def));
+    let cfg = attrs.cfg();
+    let test_id = match sema.to_def(&struct_def).map(|def| def.module(sema.db)) {
+        Some(module) => {
+            let path_iter = module
+                .path_to_root(sema.db)
+                .into_iter()
+                .rev()
+                .filter_map(|it| it.name(sema.db))
+                .map(|name| name.to_string());
+            let path = path_iter.chain(std::iter::once(name_string)).join("::");
+            TestId::Path(path)
+        }
+        None => TestId::Name(name_string),
+    };
+    let nav = NavigationTarget::from_doc_commented(
+        sema.db,
+        InFile::new(file_id.into(), &struct_def),
+        InFile::new(file_id.into(), &struct_def),
+    );
+    Some(Runnable { nav, kind: RunnableKind::DocTest { test_id }, cfg })
+}
 #[derive(Debug, Copy, Clone)]
 pub struct TestAttr {
    pub ignore: bool,
@@ -215,8 +253,8 @@ const RUSTDOC_FENCE: &str = "```";
 const RUSTDOC_CODE_BLOCK_ATTRIBUTES_RUNNABLE: &[&str] =
    &["", "rust", "should_panic", "edition2015", "edition2018"];
-fn has_runnable_doc_test(fn_def: &ast::Fn) -> bool {
+fn has_runnable_doc_test(def: &dyn DocCommentsOwner) -> bool {
-    fn_def.doc_comment_text().map_or(false, |comments_text| {
+    def.doc_comment_text().map_or(false, |comments_text| {
        let mut in_code_block = false;
        for line in comments_text.lines() {
@@ -487,8 +525,14 @@ fn should_have_no_runnable_5() {}
 /// let z = 55;
 /// ```
 fn should_have_no_runnable_6() {}
+/// ```
+/// let x = 5;
+/// ```
+struct StructWithRunnable(String);
 "#,
-            &[&BIN, &DOCTEST, &DOCTEST, &DOCTEST],
+            &[&BIN, &DOCTEST, &DOCTEST, &DOCTEST, &DOCTEST],
            expect![[r#"
                [
                    Runnable {
@@ -569,6 +613,26 @@ fn should_have_no_runnable_6() {}
                        },
                        cfg: None,
                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 756..821,
+                            focus_range: None,
+                            name: "StructWithRunnable",
+                            kind: STRUCT,
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "StructWithRunnable",
+                            ),
+                        },
+                        cfg: None,
+                    },
                ]
            "#]],
        );
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 624a63075..efcc8ecfe 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -2,7 +2,7 @@ mod format;
 mod html;
 mod injection;
 mod macro_rules;
-mod tags;
+pub(crate) mod tags;
 #[cfg(test)]
 mod tests;
@@ -20,12 +20,13 @@ use syntax::{
 };
 use crate::{
-    syntax_highlighting::{format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter},
+    syntax_highlighting::{
-    FileId,
+        format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
+    },
+    FileId, HighlightModifier, HighlightTag,
 };
 pub(crate) use html::highlight_as_html;
-pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
 #[derive(Debug, Clone)]
 pub struct HighlightedRange {
diff --git a/crates/mbe/src/mbe_expander/matcher.rs b/crates/mbe/src/mbe_expander/matcher.rs
index b698b9832..39a8eefbd 100644
--- a/crates/mbe/src/mbe_expander/matcher.rs
+++ b/crates/mbe/src/mbe_expander/matcher.rs
@@ -61,16 +61,16 @@ macro_rules! err {
 #[derive(Debug, Default)]
 pub(super) struct Match {
-    pub bindings: Bindings,
+    pub(super) bindings: Bindings,
    /// We currently just keep the first error and count the rest to compare matches.
-    pub err: Option<ExpandError>,
+    pub(super) err: Option<ExpandError>,
-    pub err_count: usize,
+    pub(super) err_count: usize,
    /// How many top-level token trees were left to match.
-    pub unmatched_tts: usize,
+    pub(super) unmatched_tts: usize,
 }
 impl Match {
-    pub fn add_err(&mut self, err: ExpandError) {
+    pub(super) fn add_err(&mut self, err: ExpandError) {
        let prev_err = self.err.take();
        self.err = prev_err.or(Some(err));
        self.err_count += 1;
diff --git a/crates/mbe/src/subtree_source.rs b/crates/mbe/src/subtree_source.rs
index 396ce8b16..ccc56c479 100644
--- a/crates/mbe/src/subtree_source.rs
+++ b/crates/mbe/src/subtree_source.rs
@@ -7,9 +7,9 @@ use tt::buffer::{Cursor, TokenBuffer};
 #[derive(Debug, Clone, Eq, PartialEq)]
 struct TtToken {
-    pub kind: SyntaxKind,
+    kind: SyntaxKind,
-    pub is_joint_to_next: bool,
+    is_joint_to_next: bool,
-    pub text: SmolStr,
+    text: SmolStr,
 }
 pub(crate) struct SubtreeTokenSource<'a> {
@@ -21,7 +21,7 @@ pub(crate) struct SubtreeTokenSource<'a> {
 impl<'a> SubtreeTokenSource<'a> {
    // Helper function used in test
    #[cfg(test)]
-    pub fn text(&self) -> SmolStr {
+    pub(crate) fn text(&self) -> SmolStr {
        match *self.get(self.curr.1) {
            Some(ref tt) => tt.text.clone(),
            _ => SmolStr::new(""),
@@ -30,7 +30,7 @@ impl<'a> SubtreeTokenSource<'a> {
 }
 impl<'a> SubtreeTokenSource<'a> {
-    pub fn new(buffer: &'a TokenBuffer) -> SubtreeTokenSource<'a> {
+    pub(crate) fn new(buffer: &'a TokenBuffer) -> SubtreeTokenSource<'a> {
        let cursor = buffer.begin();
        let mut res = SubtreeTokenSource {
diff --git a/crates/proc_macro_api/src/process.rs b/crates/proc_macro_api/src/process.rs
index 51ffcaa78..907cb3db7 100644
--- a/crates/proc_macro_api/src/process.rs
+++ b/crates/proc_macro_api/src/process.rs
@@ -30,7 +30,7 @@ pub(crate) struct ProcMacroProcessThread {
 }
 impl ProcMacroProcessSrv {
-    pub fn run(
+    pub(crate) fn run(
        process_path: PathBuf,
        args: impl IntoIterator<Item = impl AsRef<OsStr>>,
    ) -> io::Result<(ProcMacroProcessThread, ProcMacroProcessSrv)> {
@@ -48,7 +48,7 @@ impl ProcMacroProcessSrv {
        Ok((thread, srv))
    }
-    pub fn find_proc_macros(
+    pub(crate) fn find_proc_macros(
        &self,
        dylib_path: &Path,
    ) -> Result<Vec<(String, ProcMacroKind)>, tt::ExpansionError> {
@@ -58,7 +58,7 @@ impl ProcMacroProcessSrv {
        Ok(result.macros)
    }
-    pub fn custom_derive(
+    pub(crate) fn custom_derive(
        &self,
        dylib_path: &Path,
        subtree: &Subtree,
@@ -75,7 +75,7 @@ impl ProcMacroProcessSrv {
        Ok(result.expansion)
    }
-    pub fn send_task<R>(&self, req: Request) -> Result<R, tt::ExpansionError>
+    pub(crate) fn send_task<R>(&self, req: Request) -> Result<R, tt::ExpansionError>
    where
        R: TryFrom<Response, Error = &'static str>,
    {
diff --git a/crates/proc_macro_api/src/rpc.rs b/crates/proc_macro_api/src/rpc.rs
index 47624163e..203109ca4 100644
--- a/crates/proc_macro_api/src/rpc.rs
+++ b/crates/proc_macro_api/src/rpc.rs
@@ -75,18 +75,18 @@ struct TokenIdDef(u32);
 #[serde(remote = "Delimiter")]
 struct DelimiterDef {
    #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
    #[serde(with = "DelimiterKindDef")]
-    pub kind: DelimiterKind,
+    kind: DelimiterKind,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Subtree")]
 struct SubtreeDef {
    #[serde(default, with = "opt_delimiter_def")]
-    pub delimiter: Option<Delimiter>,
+    delimiter: Option<Delimiter>,
    #[serde(with = "vec_token_tree")]
-    pub token_trees: Vec<TokenTree>,
+    token_trees: Vec<TokenTree>,
 }
 #[derive(Serialize, Deserialize)]
@@ -112,19 +112,19 @@ enum LeafDef {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Literal")]
 struct LiteralDef {
-    pub text: SmolStr,
+    text: SmolStr,
    #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Punct")]
 struct PunctDef {
-    pub char: char,
+    char: char,
    #[serde(with = "SpacingDef")]
-    pub spacing: Spacing,
+    spacing: Spacing,
    #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
 }
 #[derive(Serialize, Deserialize)]
@@ -137,16 +137,16 @@ enum SpacingDef {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Ident")]
 struct IdentDef {
-    pub text: SmolStr,
+    text: SmolStr,
    #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
 }
 mod opt_delimiter_def {
    use super::{Delimiter, DelimiterDef};
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-    pub fn serialize<S>(value: &Option<Delimiter>, serializer: S) -> Result<S::Ok, S::Error>
+    pub(super) fn serialize<S>(value: &Option<Delimiter>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
@@ -155,7 +155,7 @@ mod opt_delimiter_def {
        value.as_ref().map(Helper).serialize(serializer)
    }
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Delimiter>, D::Error>
+    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Option<Delimiter>, D::Error>
    where
        D: Deserializer<'de>,
    {
@@ -170,7 +170,7 @@ mod opt_subtree_def {
    use super::{Subtree, SubtreeDef};
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-    pub fn serialize<S>(value: &Option<Subtree>, serializer: S) -> Result<S::Ok, S::Error>
+    pub(super) fn serialize<S>(value: &Option<Subtree>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
@@ -179,7 +179,7 @@ mod opt_subtree_def {
        value.as_ref().map(Helper).serialize(serializer)
    }
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Subtree>, D::Error>
+    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Option<Subtree>, D::Error>
    where
        D: Deserializer<'de>,
    {
@@ -194,7 +194,7 @@ mod vec_token_tree {
    use super::{TokenTree, TokenTreeDef};
    use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
-    pub fn serialize<S>(value: &Vec<TokenTree>, serializer: S) -> Result<S::Ok, S::Error>
+    pub(super) fn serialize<S>(value: &Vec<TokenTree>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
@@ -209,7 +209,7 @@ mod vec_token_tree {
        seq.end()
    }
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<TokenTree>, D::Error>
+    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Vec<TokenTree>, D::Error>
    where
        D: Deserializer<'de>,
    {
diff --git a/crates/proc_macro_srv/src/lib.rs b/crates/proc_macro_srv/src/lib.rs
index 7e4e4ad50..6e890f8e2 100644
--- a/crates/proc_macro_srv/src/lib.rs
+++ b/crates/proc_macro_srv/src/lib.rs
@@ -9,6 +9,7 @@
 //!   RA than `proc-macro2` token stream.
 //! * By **copying** the whole rustc `lib_proc_macro` code, we are able to build this with `stable`
 //!   rustc rather than `unstable`. (Although in general ABI compatibility is still an issue)…
+#![allow(unreachable_pub)]
 #[allow(dead_code)]
 #[doc(hidden)]
diff --git a/crates/profile/src/hprof.rs b/crates/profile/src/hprof.rs
index 934cc8e37..8957ea016 100644
--- a/crates/profile/src/hprof.rs
+++ b/crates/profile/src/hprof.rs
@@ -27,7 +27,7 @@ pub fn init_from(spec: &str) {
    filter.install();
 }
-pub type Label = &'static str;
+type Label = &'static str;
 /// This function starts a profiling scope in the current execution stack with a given description.
 /// It returns a `Profile` struct that measures elapsed time between this method invocation and `Profile` struct drop.
@@ -173,7 +173,7 @@ impl ProfileStack {
        true
    }
-    pub fn pop(&mut self, label: Label, detail: Option<String>) {
+    fn pop(&mut self, label: Label, detail: Option<String>) {
        let start = self.starts.pop().unwrap();
        let duration = start.elapsed();
        self.messages.finish(Message { duration, label, detail });
diff --git a/crates/profile/src/tree.rs b/crates/profile/src/tree.rs
index 096f58511..3fac1f36c 100644
--- a/crates/profile/src/tree.rs
+++ b/crates/profile/src/tree.rs
@@ -4,15 +4,15 @@ use std::ops;
 use arena::Arena;
 #[derive(Default)]
-pub struct Tree<T> {
+pub(crate) struct Tree<T> {
    nodes: Arena<Node<T>>,
    current_path: Vec<(Idx<T>, Option<Idx<T>>)>,
 }
-pub type Idx<T> = arena::Idx<Node<T>>;
+pub(crate) type Idx<T> = arena::Idx<Node<T>>;
 impl<T> Tree<T> {
-    pub fn start(&mut self)
+    pub(crate) fn start(&mut self)
    where
        T: Default,
    {
@@ -30,19 +30,19 @@ impl<T> Tree<T> {
        self.current_path.push((me, None));
    }
-    pub fn finish(&mut self, data: T) {
+    pub(crate) fn finish(&mut self, data: T) {
        let (me, _last_child) = self.current_path.pop().unwrap();
        self.nodes[me].data = data;
    }
-    pub fn root(&self) -> Option<Idx<T>> {
+    pub(crate) fn root(&self) -> Option<Idx<T>> {
        self.nodes.iter().next().map(|(idx, _)| idx)
    }
-    pub fn children(&self, idx: Idx<T>) -> impl Iterator<Item = Idx<T>> + '_ {
+    pub(crate) fn children(&self, idx: Idx<T>) -> impl Iterator<Item = Idx<T>> + '_ {
        NodeIter { nodes: &self.nodes, next: self.nodes[idx].first_child }
    }
-    pub fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
        self.nodes.clear();
        self.current_path.clear();
    }
@@ -55,7 +55,7 @@ impl<T> ops::Index<Idx<T>> for Tree<T> {
    }
 }
-pub struct Node<T> {
+pub(crate) struct Node<T> {
    data: T,
    first_child: Option<Idx<T>>,
    next_sibling: Option<Idx<T>>,
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index e5c2d2b25..d5f6a4025 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -278,13 +278,13 @@ impl CargoWorkspace {
 }
 #[derive(Debug, Clone, Default)]
-pub struct ExternResources {
+pub(crate) struct ExternResources {
    out_dirs: FxHashMap<PackageId, AbsPathBuf>,
    proc_dylib_paths: FxHashMap<PackageId, AbsPathBuf>,
    cfgs: FxHashMap<PackageId, Vec<CfgFlag>>,
 }
-pub fn load_extern_resources(
+pub(crate) fn load_extern_resources(
    cargo_toml: &Path,
    cargo_features: &CargoConfig,
 ) -> Result<ExternResources> {
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index b2ff98a15..3fe494729 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -17,7 +17,7 @@ pub struct Sysroot {
    crates: Arena<SysrootCrateData>,
 }
-pub type SysrootCrate = Idx<SysrootCrateData>;
+pub(crate) type SysrootCrate = Idx<SysrootCrateData>;
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct SysrootCrateData {
@@ -60,9 +60,7 @@ impl Sysroot {
        let mut sysroot = Sysroot { crates: Arena::default() };
        for name in SYSROOT_CRATES.trim().lines() {
-            // FIXME: first path when 1.47 comes out
+            let root = [format!("{}/src/lib.rs", name), format!("lib{}/lib.rs", name)]
-            // https://github.com/rust-lang/rust/pull/73265
-            let root = [format!("lib{}/lib.rs", name), format!("{}/src/lib.rs", name)]
                .iter()
                .map(|it| sysroot_src_dir.join(it))
                .find(|it| it.exists());
@@ -149,9 +147,6 @@ try running `rustup component add rust-src` or set `RUST_SRC_PATH`",
 fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
    // Try the new path first since the old one still exists.
-    //
-    // FIXME: remove `src` when 1.47 comes out
-    // https://github.com/rust-lang/rust/pull/73265
    let rust_src = sysroot_path.join("lib/rustlib/src/rust");
    log::debug!("Checking sysroot (looking for `library` and `src` dirs): {}", rust_src.display());
    ["library", "src"].iter().map(|it| rust_src.join(it)).find(|it| it.exists())
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 4175e569e..21fba8302 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -81,7 +81,7 @@ mod tracing_setup {
    use tracing_subscriber::Registry;
    use tracing_tree::HierarchicalLayer;
-    pub fn setup_tracing() -> super::Result<()> {
+    pub(crate) fn setup_tracing() -> super::Result<()> {
        let filter = EnvFilter::from_env("CHALK_DEBUG");
        let layer = HierarchicalLayer::default()
            .with_indent_lines(true)
diff --git a/crates/rust-analyzer/src/cli/progress_report.rs b/crates/rust-analyzer/src/cli/progress_report.rs
index 31867a1e9..bdbe565e6 100644
--- a/crates/rust-analyzer/src/cli/progress_report.rs
+++ b/crates/rust-analyzer/src/cli/progress_report.rs
@@ -4,7 +4,7 @@
 use std::io::Write;
 /// A Simple ASCII Progress Bar
-pub struct ProgressReport {
+pub(crate) struct ProgressReport {
    curr: f32,
    text: String,
    hidden: bool,
@@ -15,7 +15,7 @@ pub struct ProgressReport {
 }
 impl ProgressReport {
-    pub fn new(len: u64) -> ProgressReport {
+    pub(crate) fn new(len: u64) -> ProgressReport {
        ProgressReport {
            curr: 0.0,
            text: String::new(),
@@ -26,7 +26,7 @@ impl ProgressReport {
        }
    }
-    pub fn hidden() -> ProgressReport {
+    pub(crate) fn hidden() -> ProgressReport {
        ProgressReport {
            curr: 0.0,
            text: String::new(),
@@ -37,18 +37,18 @@ impl ProgressReport {
        }
    }
-    pub fn set_message(&mut self, msg: &str) {
+    pub(crate) fn set_message(&mut self, msg: &str) {
        self.msg = msg.to_string();
        self.tick();
    }
-    pub fn println<I: Into<String>>(&mut self, msg: I) {
+    pub(crate) fn println<I: Into<String>>(&mut self, msg: I) {
        self.clear();
        println!("{}", msg.into());
        self.tick();
    }
-    pub fn inc(&mut self, delta: u64) {
+    pub(crate) fn inc(&mut self, delta: u64) {
        self.pos += delta;
        if self.len == 0 {
            self.set_value(0.0)
@@ -58,11 +58,11 @@ impl ProgressReport {
        self.tick();
    }
-    pub fn finish_and_clear(&mut self) {
+    pub(crate) fn finish_and_clear(&mut self) {
        self.clear();