42 files changed, 1536 insertions, 1356 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 965d5aaa0..0826b056a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -891,17 +891,14 @@ version = "0.1.0"
 name = "ra_assists"
 version = "0.1.0"
 dependencies = [
- "arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "format-buf 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "join_to_string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "once_cell 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_db 0.1.0",
 "ra_fmt 0.1.0",
 "ra_hir 0.1.0",
 "ra_syntax 0.1.0",
 "ra_text_edit 0.1.0",
- "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_lexer 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "test_utils 0.1.0",
 ]
@@ -1031,8 +1028,6 @@ dependencies = [
 "lsp-server 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lsp-types 0.61.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ra_cfg 0.1.0",
- "ra_db 0.1.0",
 "ra_ide_api 0.1.0",
 "ra_prof 0.1.0",
 "ra_project_model 0.1.0",
@@ -1053,7 +1048,6 @@ dependencies = [
 name = "ra_mbe"
 version = "0.1.0"
 dependencies = [
- "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_parser 0.1.0",
 "ra_syntax 0.1.0",
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index d3b6aeb36..beebccbd9 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -6,11 +6,8 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 format-buf = "1.0.0"
-once_cell = "1.0.1"
 join_to_string = "0.1.3"
 itertools = "0.8.0"
-arrayvec = "0.4.10"
-rustc-hash = "1.0.1"
 rustc_lexer = "0.1.0"
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 189cad7d0..e270c5d60 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -138,6 +138,7 @@ impl AssistBuilder {
    /// Replaces specified `node` of text with a given string, reindenting the
    /// string to maintain `node`'s existing indent.
+    // FIXME: remove in favor of ra_syntax::edit::IndentLevel::increase_indent
    pub(crate) fn replace_node_and_indent(
        &mut self,
        node: &SyntaxNode,
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 7335cce09..e3f30b5de 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -3,7 +3,7 @@
 use std::iter;
 use hir::{db::HirDatabase, Adt, HasSource};
-use ra_syntax::ast::{self, make, AstNode, NameOwner};
+use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
 use crate::{Assist, AssistCtx, AssistId};
@@ -30,15 +30,19 @@ pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
    let variant_list = enum_def.variant_list()?;
    ctx.add_action(AssistId("fill_match_arms"), "fill match arms", |edit| {
-        let variants = variant_list.variants();
+        let indent_level = IndentLevel::from_node(match_arm_list.syntax());
-        let arms = variants
-            .filter_map(build_pat)
+        let new_arm_list = {
-            .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
+            let variants = variant_list.variants();
-        let new_arm_list = make::match_arm_list(arms);
+            let arms = variants
+                .filter_map(build_pat)
+                .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
+            indent_level.increase_indent(make::match_arm_list(arms))
+        };
        edit.target(match_expr.syntax().text_range());
        edit.set_cursor(expr.syntax().text_range().start());
-        edit.replace_node_and_indent(match_arm_list.syntax(), new_arm_list.syntax().text());
+        edit.replace_ast(match_arm_list, new_arm_list);
    });
    ctx.build()
diff --git a/crates/ra_assists/src/assists/move_bounds.rs b/crates/ra_assists/src/assists/move_bounds.rs
index f791d22b0..d2444b6b9 100644
--- a/crates/ra_assists/src/assists/move_bounds.rs
+++ b/crates/ra_assists/src/assists/move_bounds.rs
@@ -18,7 +18,7 @@ pub(crate) fn move_bounds_to_where_clause(mut ctx: AssistCtx<impl HirDatabase>)
    }
    let parent = type_param_list.syntax().parent()?;
-    if parent.children_with_tokens().find(|it| it.kind() == WHERE_CLAUSE).is_some() {
+    if parent.children_with_tokens().any(|it| it.kind() == WHERE_CLAUSE) {
        return None;
    }
diff --git a/crates/ra_batch/src/lib.rs b/crates/ra_batch/src/lib.rs
index 602beb439..df49eb13d 100644
--- a/crates/ra_batch/src/lib.rs
+++ b/crates/ra_batch/src/lib.rs
@@ -141,14 +141,8 @@ mod tests {
    #[test]
    fn test_loading_rust_analyzer() {
        let path = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap();
-        let (host, roots) = load_cargo(path).unwrap();
+        let (host, _roots) = load_cargo(path).unwrap();
-        let mut n_crates = 0;
+        let n_crates = Crate::all(host.raw_database()).len();
-        for (root, _) in roots {
-            for _krate in Crate::source_root_crates(host.raw_database(), root) {
-                n_crates += 1;
-            }
-        }
        // RA has quite a few crates, but the exact count doesn't matter
        assert!(n_crates > 20);
    }
diff --git a/crates/ra_cli/src/analysis_bench.rs b/crates/ra_cli/src/analysis_bench.rs
index 727f1e62b..8bbe5d9e8 100644
--- a/crates/ra_cli/src/analysis_bench.rs
+++ b/crates/ra_cli/src/analysis_bench.rs
@@ -8,7 +8,7 @@ use std::{
 use ra_db::{
    salsa::{Database, Durability},
-    FileId, SourceDatabase,
+    FileId, SourceDatabaseExt,
 };
 use ra_ide_api::{Analysis, AnalysisChange, AnalysisHost, FilePosition, LineCol};
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index a8a110bd9..35c867dce 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -2,7 +2,7 @@
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
-use ra_db::SourceDatabase;
+use ra_db::SourceDatabaseExt;
 use ra_hir::{AssocItem, Crate, HasBodySource, HasSource, HirDisplay, ModuleDef, Ty, TypeWalk};
 use ra_syntax::AstNode;
@@ -22,16 +22,29 @@ pub fn run(
    let mut num_crates = 0;
    let mut visited_modules = HashSet::new();
    let mut visit_queue = Vec::new();
-    for (source_root_id, project_root) in roots {
-        if project_root.is_member() {
+    let members = roots
-            for krate in Crate::source_root_crates(db, source_root_id) {
+        .into_iter()
-                num_crates += 1;
+        .filter_map(
-                let module =
+            |(source_root_id, project_root)| {
-                    krate.root_module(db).expect("crate in source root without root module");
+                if project_root.is_member() {
-                visit_queue.push(module);
+                    Some(source_root_id)
-            }
+                } else {
+                    None
+                }
+            },
+        )
+        .collect::<HashSet<_>>();
+    for krate in Crate::all(db) {
+        let module = krate.root_module(db).expect("crate without root module");
+        let file_id = module.definition_source(db).file_id;
+        if members.contains(&db.file_source_root(file_id.original_file(db))) {
+            num_crates += 1;
+            visit_queue.push(module);
        }
    }
    println!("Crates in this dir: {}", num_crates);
    let mut num_decls = 0;
    let mut funcs = Vec::new();
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index cae51b02c..eafa95921 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -57,7 +57,7 @@ impl SourceRoot {
    pub fn walk(&self) -> impl Iterator<Item = FileId> + '_ {
        self.files.values().copied()
    }
-    pub(crate) fn file_by_relative_path(&self, path: &RelativePath) -> Option<FileId> {
+    pub fn file_by_relative_path(&self, path: &RelativePath) -> Option<FileId> {
        self.files.get(path).copied()
    }
 }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 4d3a9c036..fc5d6d396 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -64,21 +64,39 @@ pub struct FileRange {
 pub const DEFAULT_LRU_CAP: usize = 128;
-/// Database which stores all significant input facts: source code and project
+pub trait FileLoader {
-/// model. Everything else in rust-analyzer is derived from these queries.
-#[salsa::query_group(SourceDatabaseStorage)]
-pub trait SourceDatabase: CheckCanceled + std::fmt::Debug {
    /// Text of the file.
-    #[salsa::input]
    fn file_text(&self, file_id: FileId) -> Arc<String>;
-    #[salsa::transparent]
    fn resolve_relative_path(&self, anchor: FileId, relative_path: &RelativePath)
        -> Option<FileId>;
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>>;
+}
+/// Database which stores all significant input facts: source code and project
+/// model. Everything else in rust-analyzer is derived from these queries.
+#[salsa::query_group(SourceDatabaseStorage)]
+pub trait SourceDatabase: CheckCanceled + FileLoader + std::fmt::Debug {
    // Parses the file into the syntax tree.
    #[salsa::invoke(parse_query)]
    fn parse(&self, file_id: FileId) -> Parse<ast::SourceFile>;
+    /// The crate graph.
+    #[salsa::input]
+    fn crate_graph(&self) -> Arc<CrateGraph>;
+}
+fn parse_query(db: &impl SourceDatabase, file_id: FileId) -> Parse<ast::SourceFile> {
+    let _p = profile("parse_query");
+    let text = db.file_text(file_id);
+    SourceFile::parse(&*text)
+}
+/// We don't want to give HIR knowledge of source roots, hence we extract these
+/// methods into a separate DB.
+#[salsa::query_group(SourceDatabaseExtStorage)]
+pub trait SourceDatabaseExt: SourceDatabase {
+    #[salsa::input]
+    fn file_text(&self, file_id: FileId) -> Arc<String>;
    /// Path to a file, relative to the root of its source root.
    #[salsa::input]
    fn file_relative_path(&self, file_id: FileId) -> RelativePathBuf;
@@ -88,40 +106,48 @@ pub trait SourceDatabase: CheckCanceled + std::fmt::Debug {
    /// Contents of the source root.
    #[salsa::input]
    fn source_root(&self, id: SourceRootId) -> Arc<SourceRoot>;
-    fn source_root_crates(&self, id: SourceRootId) -> Arc<Vec<CrateId>>;
-    /// The crate graph.
-    #[salsa::input]
-    fn crate_graph(&self) -> Arc<CrateGraph>;
-}
-fn resolve_relative_path(
+    fn source_root_crates(&self, id: SourceRootId) -> Arc<Vec<CrateId>>;
-    db: &impl SourceDatabase,
-    anchor: FileId,
-    relative_path: &RelativePath,
-) -> Option<FileId> {
-    let path = {
-        let mut path = db.file_relative_path(anchor);
-        // Workaround for relative path API: turn `lib.rs` into ``.
-        if !path.pop() {
-            path = RelativePathBuf::default();
-        }
-        path.push(relative_path);
-        path.normalize()
-    };
-    let source_root = db.file_source_root(anchor);
-    let source_root = db.source_root(source_root);
-    source_root.file_by_relative_path(&path)
 }
-fn source_root_crates(db: &impl SourceDatabase, id: SourceRootId) -> Arc<Vec<CrateId>> {
+fn source_root_crates(
+    db: &(impl SourceDatabaseExt + SourceDatabase),
+    id: SourceRootId,
+) -> Arc<Vec<CrateId>> {
    let root = db.source_root(id);
    let graph = db.crate_graph();
    let res = root.walk().filter_map(|it| graph.crate_id_for_crate_root(it)).collect::<Vec<_>>();
    Arc::new(res)
 }
-fn parse_query(db: &impl SourceDatabase, file_id: FileId) -> Parse<ast::SourceFile> {
+/// Silly workaround for cyclic deps between the traits
-    let _p = profile("parse_query");
+pub struct FileLoaderDelegate<T>(pub T);
-    let text = db.file_text(file_id);
-    SourceFile::parse(&*text)
+impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
+    fn file_text(&self, file_id: FileId) -> Arc<String> {
+        SourceDatabaseExt::file_text(self.0, file_id)
+    }
+    fn resolve_relative_path(
+        &self,
+        anchor: FileId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        let path = {
+            let mut path = self.0.file_relative_path(anchor);
+            // Workaround for relative path API: turn `lib.rs` into ``.
+            if !path.pop() {
+                path = RelativePathBuf::default();
+            }
+            path.push(relative_path);
+            path.normalize()
+        };
+        let source_root = self.0.file_source_root(anchor);
+        let source_root = self.0.source_root(source_root);
+        source_root.file_by_relative_path(&path)
+    }
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+        let source_root = self.0.file_source_root(file_id);
+        self.0.source_root_crates(source_root)
+    }
 }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 8055a07db..8eb3c577d 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -5,7 +5,7 @@ pub(crate) mod docs;
 use std::sync::Arc;
-use ra_db::{CrateId, Edition, FileId, SourceRootId};
+use ra_db::{CrateId, Edition, FileId};
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
 use crate::{
@@ -76,10 +76,8 @@ impl Crate {
        crate_graph.edition(self.crate_id)
    }
-    // FIXME: should this be in source_binder?
+    pub fn all(db: &impl DefDatabase) -> Vec<Crate> {
-    pub fn source_root_crates(db: &impl DefDatabase, source_root: SourceRootId) -> Vec<Crate> {
+        db.crate_graph().iter().map(|crate_id| Crate { crate_id }).collect()
-        let crate_ids = db.source_root_crates(source_root);
-        crate_ids.iter().map(|&crate_id| Crate { crate_id }).collect()
    }
 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 73d7d6fb6..489a3b19c 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -111,37 +111,37 @@ pub trait DefDatabase: InternDatabase + HirDebugDatabase {
    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
    fn crate_def_map(&self, krate: Crate) -> Arc<CrateDefMap>;
-    #[salsa::invoke(crate::impl_block::impls_in_module_with_source_map_query)]
+    #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)]
    fn impls_in_module_with_source_map(
        &self,
        module: Module,
    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
-    #[salsa::invoke(crate::impl_block::impls_in_module)]
+    #[salsa::invoke(ModuleImplBlocks::impls_in_module_query)]
    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
    #[salsa::invoke(crate::generics::GenericParams::generic_params_query)]
    fn generic_params(&self, def: GenericDef) -> Arc<GenericParams>;
-    #[salsa::invoke(crate::FnData::fn_data_query)]
+    #[salsa::invoke(FnData::fn_data_query)]
    fn fn_data(&self, func: Function) -> Arc<FnData>;
-    #[salsa::invoke(crate::type_alias::type_alias_data_query)]
+    #[salsa::invoke(TypeAliasData::type_alias_data_query)]
    fn type_alias_data(&self, typ: TypeAlias) -> Arc<TypeAliasData>;
-    #[salsa::invoke(crate::ConstData::const_data_query)]
+    #[salsa::invoke(ConstData::const_data_query)]
    fn const_data(&self, konst: Const) -> Arc<ConstData>;
-    #[salsa::invoke(crate::ConstData::static_data_query)]
+    #[salsa::invoke(ConstData::static_data_query)]
    fn static_data(&self, konst: Static) -> Arc<ConstData>;
-    #[salsa::invoke(crate::lang_item::LangItems::module_lang_items_query)]
+    #[salsa::invoke(LangItems::module_lang_items_query)]
    fn module_lang_items(&self, module: Module) -> Option<Arc<LangItems>>;
-    #[salsa::invoke(crate::lang_item::LangItems::crate_lang_items_query)]
+    #[salsa::invoke(LangItems::crate_lang_items_query)]
    fn crate_lang_items(&self, krate: Crate) -> Arc<LangItems>;
-    #[salsa::invoke(crate::lang_item::LangItems::lang_item_query)]
+    #[salsa::invoke(LangItems::lang_item_query)]
    fn lang_item(&self, start_crate: Crate, item: SmolStr) -> Option<LangItemTarget>;
    #[salsa::invoke(crate::code_model::docs::documentation_query)]
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index a012f33f7..f80d8eb5f 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -189,14 +189,14 @@ impl Module {
            ModuleSource::SourceFile(_) => None,
        };
-        let source_root_id = db.file_source_root(src.file_id.original_file(db));
+        db.relevant_crates(src.file_id.original_file(db))
-        db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
+            .iter()
-            |krate| {
+            .map(|&crate_id| Crate { crate_id })
+            .find_map(|krate| {
                let def_map = db.crate_def_map(krate);
                let module_id = def_map.find_module_by_source(src.file_id, decl_id)?;
                Some(Module { krate, module_id })
-            },
+            })
-        )
    }
 }
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 85b022744..499dcafea 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -85,11 +85,7 @@ impl HirFileId {
                // Note:
                // The final goal we would like to make all parse_macro success,
                // such that the following log will not call anyway.
-                log::warn!(
+                log::warn!("fail on macro_parse: (reason: {})", err,);
-                    "fail on macro_parse: (reason: {}) {}",
-                    err,
-                    macro_call_id.debug_dump(db)
-                );
            })
            .ok()?;
        match macro_file.macro_file_kind {
@@ -367,35 +363,6 @@ impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
    }
 }
-impl MacroCallId {
-    pub fn debug_dump(self, db: &impl AstDatabase) -> String {
-        let loc = self.loc(db);
-        let node = loc.ast_id.to_node(db);
-        let syntax_str = {
-            let mut res = String::new();
-            node.syntax().text().for_each_chunk(|chunk| {
-                if !res.is_empty() {
-                    res.push(' ')
-                }
-                res.push_str(chunk)
-            });
-            res
-        };
-        // dump the file name
-        let file_id: HirFileId = self.loc(db).ast_id.file_id();
-        let original = file_id.original_file(db);
-        let macro_rules = db.macro_def(loc.def);
-        format!(
-            "macro call [file: {:?}] : {}\nhas rules: {}",
-            db.file_relative_path(original),
-            syntax_str,
-            macro_rules.is_some()
-        )
-    }
-}
 /// This exists just for Chalk, because Chalk just has a single `StructId` where
 /// we have different kinds of ADTs, primitive types and special type
 /// constructors like tuples and function pointers.
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 55dfc393b..33ef87563 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -176,6 +176,25 @@ pub struct ModuleImplBlocks {
 }
 impl ModuleImplBlocks {
+    pub(crate) fn impls_in_module_with_source_map_query(
+        db: &(impl DefDatabase + AstDatabase),
+        module: Module,
+    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
+        let mut source_map = ImplSourceMap::default();
+        let crate_graph = db.crate_graph();
+        let cfg_options = crate_graph.cfg_options(module.krate.crate_id());
+        let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
+        (Arc::new(result), Arc::new(source_map))
+    }
+    pub(crate) fn impls_in_module_query(
+        db: &impl DefDatabase,
+        module: Module,
+    ) -> Arc<ModuleImplBlocks> {
+        db.impls_in_module_with_source_map(module).0
+    }
    fn collect(
        db: &(impl DefDatabase + AstDatabase),
        cfg_options: &CfgOptions,
@@ -264,19 +283,3 @@ impl ModuleImplBlocks {
        }
    }
 }
-pub(crate) fn impls_in_module_with_source_map_query(
-    db: &(impl DefDatabase + AstDatabase),
-    module: Module,
-) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
-    let mut source_map = ImplSourceMap::default();
-    let crate_graph = db.crate_graph();
-    let cfg_options = crate_graph.cfg_options(module.krate.crate_id());
-    let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
-    (Arc::new(result), Arc::new(source_map))
-}
-pub(crate) fn impls_in_module(db: &impl DefDatabase, module: Module) -> Arc<ModuleImplBlocks> {
-    db.impls_in_module_with_source_map(module).0
-}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 9cbd9a8ae..ca261e8f5 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -51,6 +51,7 @@ mod lang_item;
 mod generics;
 mod resolve;
 pub mod diagnostics;
+mod util;
 mod code_model;
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 827424983..0b278deb3 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -5,10 +5,10 @@ use std::{panic, sync::Arc};
 use parking_lot::Mutex;
 use ra_cfg::CfgOptions;
 use ra_db::{
-    salsa, CrateGraph, CrateId, Edition, FileId, FilePosition, SourceDatabase, SourceRoot,
+    salsa, CrateGraph, CrateId, Edition, FileId, FileLoader, FileLoaderDelegate, FilePosition,
-    SourceRootId,
+    SourceDatabase, SourceDatabaseExt, SourceRoot, SourceRootId,
 };
-use relative_path::RelativePathBuf;
+use relative_path::{RelativePath, RelativePathBuf};
 use rustc_hash::FxHashMap;
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
@@ -17,6 +17,7 @@ use crate::{db, debug::HirDebugHelper, diagnostics::DiagnosticSink};
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
 #[salsa::database(
+    ra_db::SourceDatabaseExtStorage,
    ra_db::SourceDatabaseStorage,
    db::InternDatabaseStorage,
    db::AstDatabaseStorage,
@@ -34,6 +35,22 @@ pub struct MockDatabase {
 impl panic::RefUnwindSafe for MockDatabase {}
+impl FileLoader for MockDatabase {
+    fn file_text(&self, file_id: FileId) -> Arc<String> {
+        FileLoaderDelegate(self).file_text(file_id)
+    }
+    fn resolve_relative_path(
+        &self,
+        anchor: FileId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
+    }
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+        FileLoaderDelegate(self).relevant_crates(file_id)
+    }
+}
 impl HirDebugHelper for MockDatabase {
    fn crate_name(&self, krate: CrateId) -> Option<String> {
        self.crate_names.get(&krate).cloned()
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
index c41862a0b..af9c39760 100644
--- a/crates/ra_hir/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -2,7 +2,7 @@ use super::*;
 use std::sync::Arc;
-use ra_db::SourceDatabase;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
 fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) {
    let (mut db, pos) = MockDatabase::with_position(initial);
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index d161735e8..cc9746f6d 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -17,8 +17,8 @@ use std::sync::Arc;
 use std::{fmt, iter, mem};
 use crate::{
-    db::HirDatabase, expr::ExprId, type_ref::Mutability, Adt, Crate, DefWithBody, GenericParams,
+    db::HirDatabase, expr::ExprId, type_ref::Mutability, util::make_mut_slice, Adt, Crate,
-    HasGenericParams, Name, Trait, TypeAlias,
+    DefWithBody, GenericParams, HasGenericParams, Name, Trait, TypeAlias,
 };
 use display::{HirDisplay, HirFormatter};
@@ -308,12 +308,9 @@ impl Substs {
    }
    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
-        // Without an Arc::make_mut_slice, we can't avoid the clone here:
+        for t in make_mut_slice(&mut self.0) {
-        let mut v: Vec<_> = self.0.iter().cloned().collect();
-        for t in &mut v {
            t.walk_mut(f);
        }
-        self.0 = v.into();
    }
    pub fn as_single(&self) -> &Ty {
@@ -330,8 +327,7 @@ impl Substs {
                .params_including_parent()
                .into_iter()
                .map(|p| Ty::Param { idx: p.idx, name: p.name.clone() })
-                .collect::<Vec<_>>()
+                .collect(),
-                .into(),
        )
    }
@@ -342,8 +338,7 @@ impl Substs {
                .params_including_parent()
                .into_iter()
                .map(|p| Ty::Bound(p.idx))
-                .collect::<Vec<_>>()
+                .collect(),
-                .into(),
        )
    }
@@ -541,12 +536,9 @@ impl TypeWalk for FnSig {
    }
    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
-        // Without an Arc::make_mut_slice, we can't avoid the clone here:
+        for t in make_mut_slice(&mut self.params_and_return) {
-        let mut v: Vec<_> = self.params_and_return.iter().cloned().collect();
-        for t in &mut v {
            t.walk_mut(f);
        }
-        self.params_and_return = v.into();
    }
 }
@@ -756,11 +748,9 @@ impl TypeWalk for Ty {
                p_ty.parameters.walk_mut(f);
            }
            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
-                let mut v: Vec<_> = predicates.iter().cloned().collect();
+                for p in make_mut_slice(predicates) {
-                for p in &mut v {
                    p.walk_mut(f);
                }
-                *predicates = v.into();
            }
            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
        }
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index a69f04ff1..cb28fc6bc 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -14,7 +14,6 @@
 //! the `ena` crate, which is extracted from rustc.
 use std::borrow::Cow;
-use std::iter::{repeat, repeat_with};
 use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
@@ -27,33 +26,39 @@ use ra_prof::profile;
 use test_utils::tested_by;
 use super::{
-    autoderef, lower, method_resolution, op, primitive,
+    lower, primitive,
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    ApplicationTy, CallableDef, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef,
+    ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypableDef,
-    Ty, TypableDef, TypeCtor, TypeWalk,
+    TypeCtor, TypeWalk,
 };
 use crate::{
    adt::VariantDef,
    code_model::TypeAlias,
    db::HirDatabase,
    diagnostics::DiagnosticSink,
-    expr::{
+    expr::{BindingAnnotation, Body, ExprId, PatId},
-        self, Array, BinaryOp, BindingAnnotation, Body, Expr, ExprId, Literal, Pat, PatId,
-        RecordFieldPat, Statement, UnaryOp,
-    },
-    generics::{GenericParams, HasGenericParams},
-    lang_item::LangItemTarget,
    name,
-    nameres::Namespace,
+    path::known,
-    path::{known, GenericArg, GenericArgs},
    resolve::{Resolver, TypeNs},
    ty::infer::diagnostics::InferenceDiagnostic,
    type_ref::{Mutability, TypeRef},
-    Adt, AssocItem, ConstData, DefWithBody, FnData, Function, HasBody, Name, Path, StructField,
+    Adt, AssocItem, ConstData, DefWithBody, FnData, Function, HasBody, Path, StructField,
 };
+macro_rules! ty_app {
+    ($ctor:pat, $param:pat) => {
+        crate::ty::Ty::Apply(crate::ty::ApplicationTy { ctor: $ctor, parameters: $param })
+    };
+    ($ctor:pat) => {
+        ty_app!($ctor, _)
+    };
+}
 mod unify;
 mod path;
+mod expr;
+mod pat;
+mod coerce;
 /// The entry point of type inference.
 pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
@@ -197,15 +202,6 @@ struct InferenceContext<'a, D: HirDatabase> {
    coerce_unsized_map: FxHashMap<(TypeCtor, TypeCtor), usize>,
 }
-macro_rules! ty_app {
-    ($ctor:pat, $param:pat) => {
-        Ty::Apply(ApplicationTy { ctor: $ctor, parameters: $param })
-    };
-    ($ctor:pat) => {
-        ty_app!($ctor, _)
-    };
-}
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn new(db: &'a D, body: Arc<Body>, resolver: Resolver) -> Self {
        InferenceContext {
@@ -221,45 +217,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        }
    }
-    fn init_coerce_unsized_map(
-        db: &'a D,
-        resolver: &Resolver,
-    ) -> FxHashMap<(TypeCtor, TypeCtor), usize> {
-        let krate = resolver.krate().unwrap();
-        let impls = match db.lang_item(krate, "coerce_unsized".into()) {
-            Some(LangItemTarget::Trait(trait_)) => db.impls_for_trait(krate, trait_),
-            _ => return FxHashMap::default(),
-        };
-        impls
-            .iter()
-            .filter_map(|impl_block| {
-                // `CoerseUnsized` has one generic parameter for the target type.
-                let trait_ref = impl_block.target_trait_ref(db)?;
-                let cur_from_ty = trait_ref.substs.0.get(0)?;
-                let cur_to_ty = trait_ref.substs.0.get(1)?;
-                match (&cur_from_ty, cur_to_ty) {
-                    (ty_app!(ctor1, st1), ty_app!(ctor2, st2)) => {
-                        // FIXME: We return the first non-equal bound as the type parameter to coerce to unsized type.
-                        // This works for smart-pointer-like coercion, which covers all impls from std.
-                        st1.iter().zip(st2.iter()).enumerate().find_map(|(i, (ty1, ty2))| {
-                            match (ty1, ty2) {
-                                (Ty::Param { idx: p1, .. }, Ty::Param { idx: p2, .. })
-                                    if p1 != p2 =>
-                                {
-                                    Some(((*ctor1, *ctor2), i))
-                                }
-                                _ => None,
-                            }
-                        })
-                    }
-                    _ => None,
-                }
-            })
-            .collect()
-    }
    fn resolve_all(mut self) -> InferenceResult {
        // FIXME resolve obligations as well (use Guidance if necessary)
        let mut result = mem::replace(&mut self.result, InferenceResult::default());
@@ -595,1080 +552,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        }
    }
-    fn infer_tuple_struct_pat(
-        &mut self,
-        path: Option<&Path>,
-        subpats: &[PatId],
-        expected: &Ty,
-        default_bm: BindingMode,
-    ) -> Ty {
-        let (ty, def) = self.resolve_variant(path);
-        self.unify(&ty, expected);
-        let substs = ty.substs().unwrap_or_else(Substs::empty);
-        for (i, &subpat) in subpats.iter().enumerate() {
-            let expected_ty = def
-                .and_then(|d| d.field(self.db, &Name::new_tuple_field(i)))
-                .map_or(Ty::Unknown, |field| field.ty(self.db))
-                .subst(&substs);
-            let expected_ty = self.normalize_associated_types_in(expected_ty);
-            self.infer_pat(subpat, &expected_ty, default_bm);
-        }
-        ty
-    }
-    fn infer_record_pat(
-        &mut self,
-        path: Option<&Path>,
-        subpats: &[RecordFieldPat],
-        expected: &Ty,
-        default_bm: BindingMode,
-        id: PatId,
-    ) -> Ty {
-        let (ty, def) = self.resolve_variant(path);
-        if let Some(variant) = def {
-            self.write_variant_resolution(id.into(), variant);
-        }
-        self.unify(&ty, expected);
-        let substs = ty.substs().unwrap_or_else(Substs::empty);
-        for subpat in subpats {
-            let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
-            let expected_ty =
-                matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
-            let expected_ty = self.normalize_associated_types_in(expected_ty);
-            self.infer_pat(subpat.pat, &expected_ty, default_bm);
-        }
-        ty
-    }
-    fn infer_pat(&mut self, pat: PatId, mut expected: &Ty, mut default_bm: BindingMode) -> Ty {
-        let body = Arc::clone(&self.body); // avoid borrow checker problem
-        let is_non_ref_pat = match &body[pat] {
-            Pat::Tuple(..)
-            | Pat::TupleStruct { .. }
-            | Pat::Record { .. }
-            | Pat::Range { .. }
-            | Pat::Slice { .. } => true,
-            // FIXME: Path/Lit might actually evaluate to ref, but inference is unimplemented.
-            Pat::Path(..) | Pat::Lit(..) => true,
-            Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
-        };
-        if is_non_ref_pat {
-            while let Some((inner, mutability)) = expected.as_reference() {
-                expected = inner;
-                default_bm = match default_bm {
-                    BindingMode::Move => BindingMode::Ref(mutability),
-                    BindingMode::Ref(Mutability::Shared) => BindingMode::Ref(Mutability::Shared),
-                    BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(mutability),
-                }
-            }
-        } else if let Pat::Ref { .. } = &body[pat] {
-            tested_by!(match_ergonomics_ref);
-            // When you encounter a `&pat` pattern, reset to Move.
-            // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
-            default_bm = BindingMode::Move;
-        }
-        // Lose mutability.
-        let default_bm = default_bm;
-        let expected = expected;
-        let ty = match &body[pat] {
-            Pat::Tuple(ref args) => {
-                let expectations = match expected.as_tuple() {
-                    Some(parameters) => &*parameters.0,
-                    _ => &[],
-                };
-                let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
-                let inner_tys = args
-                    .iter()
-                    .zip(expectations_iter)
-                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
-                    .collect();
-                Ty::apply(TypeCtor::Tuple { cardinality: args.len() as u16 }, Substs(inner_tys))
-            }
-            Pat::Ref { pat, mutability } => {
-                let expectation = match expected.as_reference() {
-                    Some((inner_ty, exp_mut)) => {
-                        if *mutability != exp_mut {
-                            // FIXME: emit type error?
-                        }
-                        inner_ty
-                    }
-                    _ => &Ty::Unknown,
-                };
-                let subty = self.infer_pat(*pat, expectation, default_bm);
-                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
-            }
-            Pat::TupleStruct { path: p, args: subpats } => {
-                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
-            }
-            Pat::Record { path: p, args: fields } => {
-                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
-            }
-            Pat::Path(path) => {
-                // FIXME use correct resolver for the surrounding expression
-                let resolver = self.resolver.clone();
-                self.infer_path(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
-            }
-            Pat::Bind { mode, name: _, subpat } => {
-                let mode = if mode == &BindingAnnotation::Unannotated {
-                    default_bm
-                } else {
-                    BindingMode::convert(*mode)
-                };
-                let inner_ty = if let Some(subpat) = subpat {
-                    self.infer_pat(*subpat, expected, default_bm)
-                } else {
-                    expected.clone()
-                };
-                let inner_ty = self.insert_type_vars_shallow(inner_ty);
-                let bound_ty = match mode {
-                    BindingMode::Ref(mutability) => {
-                        Ty::apply_one(TypeCtor::Ref(mutability), inner_ty.clone())
-                    }
-                    BindingMode::Move => inner_ty.clone(),
-                };
-                let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty);
-                self.write_pat_ty(pat, bound_ty);
-                return inner_ty;
-            }
-            _ => Ty::Unknown,
-        };
-        // use a new type variable if we got Ty::Unknown here
-        let ty = self.insert_type_vars_shallow(ty);
-        self.unify(&ty, expected);
-        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
-        self.write_pat_ty(pat, ty.clone());
-        ty
-    }
-    fn substs_for_method_call(
-        &mut self,
-        def_generics: Option<Arc<GenericParams>>,
-        generic_args: Option<&GenericArgs>,
-        receiver_ty: &Ty,
-    ) -> Substs {
-        let (parent_param_count, param_count) =
-            def_generics.as_ref().map_or((0, 0), |g| (g.count_parent_params(), g.params.len()));
-        let mut substs = Vec::with_capacity(parent_param_count + param_count);
-        // Parent arguments are unknown, except for the receiver type
-        if let Some(parent_generics) = def_generics.and_then(|p| p.parent_params.clone()) {
-            for param in &parent_generics.params {
-                if param.name == name::SELF_TYPE {
-                    substs.push(receiver_ty.clone());
-                } else {
-                    substs.push(Ty::Unknown);
-                }
-            }
-        }
-        // handle provided type arguments
-        if let Some(generic_args) = generic_args {
-            // if args are provided, it should be all of them, but we can't rely on that
-            for arg in generic_args.args.iter().take(param_count) {
-                match arg {
-                    GenericArg::Type(type_ref) => {
-                        let ty = self.make_ty(type_ref);
-                        substs.push(ty);
-                    }
-                }
-            }
-        };
-        let supplied_params = substs.len();
-        for _ in supplied_params..parent_param_count + param_count {
-            substs.push(Ty::Unknown);
-        }
-        assert_eq!(substs.len(), parent_param_count + param_count);
-        Substs(substs.into())
-    }
-    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
-        if let Ty::Apply(a_ty) = callable_ty {
-            if let TypeCtor::FnDef(def) = a_ty.ctor {
-                let generic_predicates = self.db.generic_predicates(def.into());
-                for predicate in generic_predicates.iter() {
-                    let predicate = predicate.clone().subst(&a_ty.parameters);
-                    if let Some(obligation) = Obligation::from_predicate(predicate) {
-                        self.obligations.push(obligation);
-                    }
-                }
-                // add obligation for trait implementation, if this is a trait method
-                match def {
-                    CallableDef::Function(f) => {
-                        if let Some(trait_) = f.parent_trait(self.db) {
-                            // construct a TraitDef
-                            let substs = a_ty.parameters.prefix(
-                                trait_.generic_params(self.db).count_params_including_parent(),
-                            );
-                            self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
-                        }
-                    }
-                    CallableDef::Struct(_) | CallableDef::EnumVariant(_) => {}
-                }
-            }
-        }
-    }
-    fn infer_method_call(
-        &mut self,
-        tgt_expr: ExprId,
-        receiver: ExprId,
-        args: &[ExprId],
-        method_name: &Name,
-        generic_args: Option<&GenericArgs>,
-    ) -> Ty {
-        let receiver_ty = self.infer_expr(receiver, &Expectation::none());
-        let canonicalized_receiver = self.canonicalizer().canonicalize_ty(receiver_ty.clone());
-        let resolved = method_resolution::lookup_method(
-            &canonicalized_receiver.value,
-            self.db,
-            method_name,
-            &self.resolver,
-        );
-        let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
-            Some((ty, func)) => {
-                let ty = canonicalized_receiver.decanonicalize_ty(ty);
-                self.write_method_resolution(tgt_expr, func);
-                (
-                    ty,
-                    self.db.type_for_def(func.into(), Namespace::Values),
-                    Some(func.generic_params(self.db)),
-                )
-            }
-            None => (receiver_ty, Ty::Unknown, None),
-        };
-        let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
-        let method_ty = method_ty.apply_substs(substs);
-        let method_ty = self.insert_type_vars(method_ty);
-        self.register_obligations_for_call(&method_ty);
-        let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
-            Some(sig) => {
-                if !sig.params().is_empty() {
-                    (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
-                } else {
-                    (Ty::Unknown, Vec::new(), sig.ret().clone())
-                }
-            }
-            None => (Ty::Unknown, Vec::new(), Ty::Unknown),
-        };
-        // Apply autoref so the below unification works correctly
-        // FIXME: return correct autorefs from lookup_method
-        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
-            Some((_, mutability)) => Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty),
-            _ => derefed_receiver_ty,
-        };
-        self.unify(&expected_receiver_ty, &actual_receiver_ty);
-        self.check_call_arguments(args, &param_tys);
-        let ret_ty = self.normalize_associated_types_in(ret_ty);
-        ret_ty
-    }
-    /// Infer type of expression with possibly implicit coerce to the expected type.
-    /// Return the type after possible coercion.
-    fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
-        let ty = self.infer_expr_inner(expr, &expected);
-        let ty = if !self.coerce(&ty, &expected.ty) {
-            self.result
-                .type_mismatches
-                .insert(expr, TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() });
-            // Return actual type when type mismatch.
-            // This is needed for diagnostic when return type mismatch.
-            ty
-        } else if expected.ty == Ty::Unknown {
-            ty
-        } else {
-            expected.ty.clone()
-        };
-        self.resolve_ty_as_possible(&mut vec![], ty)
-    }
-    /// Merge two types from different branches, with possible implicit coerce.
-    ///
-    /// Note that it is only possible that one type are coerced to another.
-    /// Coercing both types to another least upper bound type is not possible in rustc,
-    /// which will simply result in "incompatible types" error.
-    fn coerce_merge_branch<'t>(&mut self, ty1: &Ty, ty2: &Ty) -> Ty {
-        if self.coerce(ty1, ty2) {
-            ty2.clone()
-        } else if self.coerce(ty2, ty1) {
-            ty1.clone()
-        } else {
-            tested_by!(coerce_merge_fail_fallback);
-            // For incompatible types, we use the latter one as result
-            // to be better recovery for `if` without `else`.
-            ty2.clone()
-        }
-    }
-    /// Unify two types, but may coerce the first one to the second one
-    /// using "implicit coercion rules" if needed.
-    ///
-    /// See: https://doc.rust-lang.org/nomicon/coercions.html
-    fn coerce(&mut self, from_ty: &Ty, to_ty: &Ty) -> bool {
-        let from_ty = self.resolve_ty_shallow(from_ty).into_owned();
-        let to_ty = self.resolve_ty_shallow(to_ty);
-        self.coerce_inner(from_ty, &to_ty)
-    }
-    fn coerce_inner(&mut self, mut from_ty: Ty, to_ty: &Ty) -> bool {
-        match (&from_ty, to_ty) {
-            // Never type will make type variable to fallback to Never Type instead of Unknown.
-            (ty_app!(TypeCtor::Never), Ty::Infer(InferTy::TypeVar(tv))) => {
-                let var = self.new_maybe_never_type_var();
-                self.var_unification_table.union_value(*tv, TypeVarValue::Known(var));
-                return true;
-            }
-            (ty_app!(TypeCtor::Never), _) => return true,
-            // Trivial cases, this should go after `never` check to
-            // avoid infer result type to be never
-            _ => {
-                if self.unify_inner_trivial(&from_ty, &to_ty) {
-                    return true;
-                }
-            }
-        }
-        // Pointer weakening and function to pointer
-        match (&mut from_ty, to_ty) {
-            // `*mut T`, `&mut T, `&T`` -> `*const T`
-            // `&mut T` -> `&T`
-            // `&mut T` -> `*mut T`
-            (ty_app!(c1@TypeCtor::RawPtr(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
-            | (ty_app!(c1@TypeCtor::Ref(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
-            | (ty_app!(c1@TypeCtor::Ref(_)), ty_app!(c2@TypeCtor::Ref(Mutability::Shared)))
-            | (ty_app!(c1@TypeCtor::Ref(Mutability::Mut)), ty_app!(c2@TypeCtor::RawPtr(_))) => {
-                *c1 = *c2;
-            }
-            // Illegal mutablity conversion
-            (
-                ty_app!(TypeCtor::RawPtr(Mutability::Shared)),
-                ty_app!(TypeCtor::RawPtr(Mutability::Mut)),
-            )
-            | (
-                ty_app!(TypeCtor::Ref(Mutability::Shared)),
-                ty_app!(TypeCtor::Ref(Mutability::Mut)),
-            ) => return false,
-            // `{function_type}` -> `fn()`
-            (ty_app!(TypeCtor::FnDef(_)), ty_app!(TypeCtor::FnPtr { .. })) => {
-                match from_ty.callable_sig(self.db) {
-                    None => return false,
-                    Some(sig) => {
-                        let num_args = sig.params_and_return.len() as u16 - 1;
-                        from_ty =
-                            Ty::apply(TypeCtor::FnPtr { num_args }, Substs(sig.params_and_return));
-                    }
-                }
-            }
-            _ => {}
-        }
-        if let Some(ret) = self.try_coerce_unsized(&from_ty, &to_ty) {
-            return ret;
-        }
-        // Auto Deref if cannot coerce
-        match (&from_ty, to_ty) {
-            // FIXME: DerefMut
-            (ty_app!(TypeCtor::Ref(_), st1), ty_app!(TypeCtor::Ref(_), st2)) => {
-                self.unify_autoderef_behind_ref(&st1[0], &st2[0])
-            }
-            // Otherwise, normal unify
-            _ => self.unify(&from_ty, to_ty),
-        }
-    }
-    /// Coerce a type using `from_ty: CoerceUnsized<ty_ty>`
-    ///
-    /// See: https://doc.rust-lang.org/nightly/std/marker/trait.CoerceUnsized.html
-    fn try_coerce_unsized(&mut self, from_ty: &Ty, to_ty: &Ty) -> Option<bool> {
-        let (ctor1, st1, ctor2, st2) = match (from_ty, to_ty) {
-            (ty_app!(ctor1, st1), ty_app!(ctor2, st2)) => (ctor1, st1, ctor2, st2),
-            _ => return None,
-        };
-        let coerce_generic_index = *self.coerce_unsized_map.get(&(*ctor1, *ctor2))?;
-        // Check `Unsize` first
-        match self.check_unsize_and_coerce(
-            st1.0.get(coerce_generic_index)?,
-            st2.0.get(coerce_generic_index)?,
-            0,
-        ) {
-            Some(true) => {}
-            ret => return ret,
-        }
-        let ret = st1
-            .iter()
-            .zip(st2.iter())
-            .enumerate()
-            .filter(|&(idx, _)| idx != coerce_generic_index)
-            .all(|(_, (ty1, ty2))| self.unify(ty1, ty2));
-        Some(ret)
-    }
-    /// Check if `from_ty: Unsize<to_ty>`, and coerce to `to_ty` if it holds.
-    ///
-    /// It should not be directly called. It is only used by `try_coerce_unsized`.
-    ///
-    /// See: https://doc.rust-lang.org/nightly/std/marker/trait.Unsize.html
-    fn check_unsize_and_coerce(&mut self, from_ty: &Ty, to_ty: &Ty, depth: usize) -> Option<bool> {
-        if depth > 1000 {
-            panic!("Infinite recursion in coercion");
-        }
-        match (&from_ty, &to_ty) {
-            // `[T; N]` -> `[T]`
-            (ty_app!(TypeCtor::Array, st1), ty_app!(TypeCtor::Slice, st2)) => {
-                Some(self.unify(&st1[0], &st2[0]))
-            }
-            // `T` -> `dyn Trait` when `T: Trait`
-            (_, Ty::Dyn(_)) => {
-                // FIXME: Check predicates
-                Some(true)
-            }
-            // `(..., T)` -> `(..., U)` when `T: Unsize<U>`
-            (
-                ty_app!(TypeCtor::Tuple { cardinality: len1 }, st1),
-                ty_app!(TypeCtor::Tuple { cardinality: len2 }, st2),
-            ) => {
-                if len1 != len2 || *len1 == 0 {
-                    return None;
-                }
-                match self.check_unsize_and_coerce(
-                    st1.last().unwrap(),
-                    st2.last().unwrap(),
-                    depth + 1,
-                ) {
-                    Some(true) => {}
-                    ret => return ret,
-                }
-                let ret = st1[..st1.len() - 1]
-                    .iter()
-                    .zip(&st2[..st2.len() - 1])
-                    .all(|(ty1, ty2)| self.unify(ty1, ty2));
-                Some(ret)
-            }
-            // Foo<..., T, ...> is Unsize<Foo<..., U, ...>> if:
-            // - T: Unsize<U>
-            // - Foo is a struct
-            // - Only the last field of Foo has a type involving T
-            // - T is not part of the type of any other fields
-            // - Bar<T>: Unsize<Bar<U>>, if the last field of Foo has type Bar<T>
-            (
-                ty_app!(TypeCtor::Adt(Adt::Struct(struct1)), st1),
-                ty_app!(TypeCtor::Adt(Adt::Struct(struct2)), st2),
-            ) if struct1 == struct2 => {
-                let fields = struct1.fields(self.db);
-                let (last_field, prev_fields) = fields.split_last()?;
-                // Get the generic parameter involved in the last field.
-                let unsize_generic_index = {
-                    let mut index = None;
-                    let mut multiple_param = false;
-                    last_field.ty(self.db).walk(&mut |ty| match ty {
-                        &Ty::Param { idx, .. } => {
-                            if index.is_none() {
-                                index = Some(idx);
-                            } else if Some(idx) != index {
-                                multiple_param = true;
-                            }
-                        }
-                        _ => {}
-                    });
-                    if multiple_param {
-                        return None;
-                    }
-                    index?
-                };
-                // Check other fields do not involve it.
-                let mut multiple_used = false;
-                prev_fields.iter().for_each(|field| {
-                    field.ty(self.db).walk(&mut |ty| match ty {
-                        &Ty::Param { idx, .. } if idx == unsize_generic_index => {
-                            multiple_used = true
-                        }
-                        _ => {}
-                    })
-                });
-                if multiple_used {
-                    return None;
-                }
-                let unsize_generic_index = unsize_generic_index as usize;
-                // Check `Unsize` first
-                match self.check_unsize_and_coerce(
-                    st1.get(unsize_generic_index)?,
-                    st2.get(unsize_generic_index)?,
-                    depth + 1,
-                ) {
-                    Some(true) => {}
-                    ret => return ret,
-                }
-                // Then unify other parameters
-                let ret = st1
-                    .iter()
-                    .zip(st2.iter())
-                    .enumerate()
-                    .filter(|&(idx, _)| idx != unsize_generic_index)
-                    .all(|(_, (ty1, ty2))| self.unify(ty1, ty2));
-                Some(ret)
-            }
-            _ => None,
-        }
-    }
-    /// Unify `from_ty` to `to_ty` with optional auto Deref
-    ///
-    /// Note that the parameters are already stripped the outer reference.
-    fn unify_autoderef_behind_ref(&mut self, from_ty: &Ty, to_ty: &Ty) -> bool {
-        let canonicalized = self.canonicalizer().canonicalize_ty(from_ty.clone());
-        let to_ty = self.resolve_ty_shallow(&to_ty);
-        // FIXME: Auto DerefMut
-        for derefed_ty in
-            autoderef::autoderef(self.db, &self.resolver.clone(), canonicalized.value.clone())
-        {
-            let derefed_ty = canonicalized.decanonicalize_ty(derefed_ty.value);
-            match (&*self.resolve_ty_shallow(&derefed_ty), &*to_ty) {
-                // Stop when constructor matches.
-                (ty_app!(from_ctor, st1), ty_app!(to_ctor, st2)) if from_ctor == to_ctor => {
-                    // It will not recurse to `coerce`.
-                    return self.unify_substs(st1, st2, 0);
-                }
-                _ => {}
-            }
-        }
-        false
-    }
-    fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
-        let ty = self.infer_expr_inner(tgt_expr, expected);
-        let could_unify = self.unify(&ty, &expected.ty);
-        if !could_unify {
-            self.result.type_mismatches.insert(
-                tgt_expr,
-                TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
-            );
-        }
-        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
-        ty
-    }
-    fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
-        let body = Arc::clone(&self.body); // avoid borrow checker problem
-        let ty = match &body[tgt_expr] {
-            Expr::Missing => Ty::Unknown,
-            Expr::If { condition, then_branch, else_branch } => {
-                // if let is desugared to match, so this is always simple if
-                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
-                let then_ty = self.infer_expr_inner(*then_branch, &expected);
-                let else_ty = match else_branch {
-                    Some(else_branch) => self.infer_expr_inner(*else_branch, &expected),
-                    None => Ty::unit(),
-                };
-                self.coerce_merge_branch(&then_ty, &else_ty)
-            }
-            Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
-            Expr::TryBlock { body } => {
-                let _inner = self.infer_expr(*body, expected);
-                // FIXME should be std::result::Result<{inner}, _>
-                Ty::Unknown
-            }
-            Expr::Loop { body } => {
-                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
-                // FIXME handle break with value
-                Ty::simple(TypeCtor::Never)
-            }
-            Expr::While { condition, body } => {
-                // while let is desugared to a match loop, so this is always simple while
-                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
-                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
-                Ty::unit()
-            }
-            Expr::For { iterable, body, pat } => {
-                let iterable_ty = self.infer_expr(*iterable, &Expectation::none());
-                let pat_ty = match self.resolve_into_iter_item() {
-                    Some(into_iter_item_alias) => {
-                        let pat_ty = self.new_type_var();
-                        let projection = ProjectionPredicate {
-                            ty: pat_ty.clone(),
-                            projection_ty: ProjectionTy {
-                                associated_ty: into_iter_item_alias,
-                                parameters: Substs::single(iterable_ty),
-                            },
-                        };
-                        self.obligations.push(Obligation::Projection(projection));
-                        self.resolve_ty_as_possible(&mut vec![], pat_ty)
-                    }
-                    None => Ty::Unknown,
-                };
-                self.infer_pat(*pat, &pat_ty, BindingMode::default());
-                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
-                Ty::unit()
-            }
-            Expr::Lambda { body, args, arg_types } => {
-                assert_eq!(args.len(), arg_types.len());
-                let mut sig_tys = Vec::new();
-                for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) {
-                    let expected = if let Some(type_ref) = arg_type {
-                        self.make_ty(type_ref)
-                    } else {
-                        Ty::Unknown
-                    };
-                    let arg_ty = self.infer_pat(*arg_pat, &expected, BindingMode::default());
-                    sig_tys.push(arg_ty);
-                }
-                // add return type
-                let ret_ty = self.new_type_var();
-                sig_tys.push(ret_ty.clone());
-                let sig_ty = Ty::apply(
-                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
-                    Substs(sig_tys.into()),
-                );
-                let closure_ty = Ty::apply_one(
-                    TypeCtor::Closure { def: self.body.owner(), expr: tgt_expr },
-                    sig_ty,
-                );
-                // Eagerly try to relate the closure type with the expected
-                // type, otherwise we often won't have enough information to
-                // infer the body.
-                self.coerce(&closure_ty, &expected.ty);
-                self.infer_expr(*body, &Expectation::has_type(ret_ty));
-                closure_ty
-            }
-            Expr::Call { callee, args } => {
-                let callee_ty = self.infer_expr(*callee, &Expectation::none());
-                let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
-                    Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
-                    None => {
-                        // Not callable
-                        // FIXME: report an error
-                        (Vec::new(), Ty::Unknown)
-                    }
-                };
-                self.register_obligations_for_call(&callee_ty);
-                self.check_call_arguments(args, &param_tys);
-                let ret_ty = self.normalize_associated_types_in(ret_ty);
-                ret_ty
-            }
-            Expr::MethodCall { receiver, args, method_name, generic_args } => self
-                .infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
-            Expr::Match { expr, arms } => {
-                let input_ty = self.infer_expr(*expr, &Expectation::none());
-                let mut result_ty = self.new_maybe_never_type_var();
-                for arm in arms {
-                    for &pat in &arm.pats {
-                        let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
-                    }
-                    if let Some(guard_expr) = arm.guard {
-                        self.infer_expr(
-                            guard_expr,
-                            &Expectation::has_type(Ty::simple(TypeCtor::Bool)),
-                        );
-                    }
-                    let arm_ty = self.infer_expr_inner(arm.expr, &expected);
-                    result_ty = self.coerce_merge_branch(&result_ty, &arm_ty);
-                }
-                result_ty
-            }
-            Expr::Path(p) => {
-                // FIXME this could be more efficient...
-                let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
-                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
-            }
-            Expr::Continue => Ty::simple(TypeCtor::Never),
-            Expr::Break { expr } => {
-                if let Some(expr) = expr {
-                    // FIXME handle break with value
-                    self.infer_expr(*expr, &Expectation::none());
-                }
-                Ty::simple(TypeCtor::Never)
-            }
-            Expr::Return { expr } => {
-                if let Some(expr) = expr {
-                    self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone()));
-                }
-                Ty::simple(TypeCtor::Never)
-            }
-            Expr::RecordLit { path, fields, spread } => {
-                let (ty, def_id) = self.resolve_variant(path.as_ref());
-                if let Some(variant) = def_id {
-                    self.write_variant_resolution(tgt_expr.into(), variant);
-                }
-                self.unify(&ty, &expected.ty);
-                let substs = ty.substs().unwrap_or_else(Substs::empty);
-                for (field_idx, field) in fields.iter().enumerate() {
-                    let field_ty = def_id
-                        .and_then(|it| match it.field(self.db, &field.name) {
-                            Some(field) => Some(field),
-                            None => {
-                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
-                                    expr: tgt_expr,
-                                    field: field_idx,
-                                });
-                                None
-                            }
-                        })
-                        .map_or(Ty::Unknown, |field| field.ty(self.db))
-                        .subst(&substs);
-                    self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
-                }
-                if let Some(expr) = spread {
-                    self.infer_expr(*expr, &Expectation::has_type(ty.clone()));
-                }
-                ty
-            }
-            Expr::Field { expr, name } => {
-                let receiver_ty = self.infer_expr(*expr, &Expectation::none());
-                let canonicalized = self.canonicalizer().canonicalize_ty(receiver_ty);
-                let ty = autoderef::autoderef(
-                    self.db,
-                    &self.resolver.clone(),
-                    canonicalized.value.clone(),
-                )
-                .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
-                    Ty::Apply(a_ty) => match a_ty.ctor {
-                        TypeCtor::Tuple { .. } => name
-                            .as_tuple_index()
-                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
-                        TypeCtor::Adt(Adt::Struct(s)) => s.field(self.db, name).map(|field| {
-                            self.write_field_resolution(tgt_expr, field);
-                            field.ty(self.db).subst(&a_ty.parameters)
-                        }),
-                        _ => None,
-                    },
-                    _ => None,
-                })
-                .unwrap_or(Ty::Unknown);
-                let ty = self.insert_type_vars(ty);
-                self.normalize_associated_types_in(ty)
-            }
-            Expr::Await { expr } => {
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
-                let ty = match self.resolve_future_future_output() {
-                    Some(future_future_output_alias) => {
-                        let ty = self.new_type_var();
-                        let projection = ProjectionPredicate {
-                            ty: ty.clone(),
-                            projection_ty: ProjectionTy {
-                                associated_ty: future_future_output_alias,
-                                parameters: Substs::single(inner_ty),
-                            },
-                        };
-                        self.obligations.push(Obligation::Projection(projection));
-                        self.resolve_ty_as_possible(&mut vec![], ty)
-                    }
-                    None => Ty::Unknown,
-                };
-                ty
-            }
-            Expr::Try { expr } => {
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
-                let ty = match self.resolve_ops_try_ok() {
-                    Some(ops_try_ok_alias) => {
-                        let ty = self.new_type_var();
-                        let projection = ProjectionPredicate {
-                            ty: ty.clone(),
-                            projection_ty: ProjectionTy {
-                                associated_ty: ops_try_ok_alias,
-                                parameters: Substs::single(inner_ty),
-                            },
-                        };
-                        self.obligations.push(Obligation::Projection(projection));
-                        self.resolve_ty_as_possible(&mut vec![], ty)
-                    }
-                    None => Ty::Unknown,
-                };
-                ty
-            }
-            Expr::Cast { expr, type_ref } => {
-                let _inner_ty = self.infer_expr(*expr, &Expectation::none());
-                let cast_ty = self.make_ty(type_ref);
-                // FIXME check the cast...
-                cast_ty
-            }
-            Expr::Ref { expr, mutability } => {
-                let expectation =
-                    if let Some((exp_inner, exp_mutability)) = &expected.ty.as_reference() {
-                        if *exp_mutability == Mutability::Mut && *mutability == Mutability::Shared {
-                            // FIXME: throw type error - expected mut reference but found shared ref,
-                            // which cannot be coerced
-                        }
-                        Expectation::has_type(Ty::clone(exp_inner))
-                    } else {
-                        Expectation::none()
-                    };
-                // FIXME reference coercions etc.
-                let inner_ty = self.infer_expr(*expr, &expectation);
-                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
-            }
-            Expr::Box { expr } => {
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
-                if let Some(box_) = self.resolve_boxed_box() {
-                    Ty::apply_one(TypeCtor::Adt(box_), inner_ty)
-                } else {
-                    Ty::Unknown
-                }
-            }
-            Expr::UnaryOp { expr, op } => {
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
-                match op {
-                    UnaryOp::Deref => {
-                        let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
-                        if let Some(derefed_ty) =
-                            autoderef::deref(self.db, &self.resolver, &canonicalized.value)
-                        {
-                            canonicalized.decanonicalize_ty(derefed_ty.value)
-                        } else {
-                            Ty::Unknown
-                        }
-                    }
-                    UnaryOp::Neg => {
-                        match &inner_ty {
-                            Ty::Apply(a_ty) => match a_ty.ctor {
-                                TypeCtor::Int(primitive::UncertainIntTy::Unknown)
-                                | TypeCtor::Int(primitive::UncertainIntTy::Known(
-                                    primitive::IntTy {
-                                        signedness: primitive::Signedness::Signed,
-                                        ..
-                                    },
-                                ))
-                                | TypeCtor::Float(..) => inner_ty,
-                                _ => Ty::Unknown,
-                            },
-                            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => {
-                                inner_ty
-                            }
-                            // FIXME: resolve ops::Neg trait
-                            _ => Ty::Unknown,
-                        }
-                    }
-                    UnaryOp::Not => {
-                        match &inner_ty {
-                            Ty::Apply(a_ty) => match a_ty.ctor {
-                                TypeCtor::Bool | TypeCtor::Int(_) => inner_ty,
-                                _ => Ty::Unknown,
-                            },
-                            Ty::Infer(InferTy::IntVar(..)) => inner_ty,
-                            // FIXME: resolve ops::Not trait for inner_ty
-                            _ => Ty::Unknown,
-                        }
-                    }
-                }
-            }
-            Expr::BinaryOp { lhs, rhs, op } => match op {
-                Some(op) => {
-                    let lhs_expectation = match op {
-                        BinaryOp::LogicOp(..) => Expectation::has_type(Ty::simple(TypeCtor::Bool)),
-                        _ => Expectation::none(),
-                    };
-                    let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
-                    // FIXME: find implementation of trait corresponding to operation
-                    // symbol and resolve associated `Output` type
-                    let rhs_expectation = op::binary_op_rhs_expectation(*op, lhs_ty);
-                    let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation));
-                    // FIXME: similar as above, return ty is often associated trait type
-                    op::binary_op_return_ty(*op, rhs_ty)
-                }
-                _ => Ty::Unknown,
-            },
-            Expr::Index { base, index } => {
-                let _base_ty = self.infer_expr(*base, &Expectation::none());
-                let _index_ty = self.infer_expr(*index, &Expectation::none());
-                // FIXME: use `std::ops::Index::Output` to figure out the real return type
-                Ty::Unknown
-            }
-            Expr::Tuple { exprs } => {
-                let mut tys = match &expected.ty {
-                    ty_app!(TypeCtor::Tuple { .. }, st) => st
-                        .iter()
-                        .cloned()
-                        .chain(repeat_with(|| self.new_type_var()))
-                        .take(exprs.len())
-                        .collect::<Vec<_>>(),
-                    _ => (0..exprs.len()).map(|_| self.new_type_var()).collect(),
-                };
-                for (expr, ty) in exprs.iter().zip(tys.iter_mut()) {
-                    self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
-                }
-                Ty::apply(TypeCtor::Tuple { cardinality: tys.len() as u16 }, Substs(tys.into()))
-            }
-            Expr::Array(array) => {
-                let elem_ty = match &expected.ty {
-                    ty_app!(TypeCtor::Array, st) | ty_app!(TypeCtor::Slice, st) => {
-                        st.as_single().clone()
-                    }
-                    _ => self.new_type_var(),
-                };
-                match array {
-                    Array::ElementList(items) => {
-                        for expr in items.iter() {
-                            self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
-                        }
-                    }
-                    Array::Repeat { initializer, repeat } => {
-                        self.infer_expr_coerce(
-                            *initializer,
-                            &Expectation::has_type(elem_ty.clone()),
-                        );
-                        self.infer_expr(
-                            *repeat,
-                            &Expectation::has_type(Ty::simple(TypeCtor::Int(
-                                primitive::UncertainIntTy::Known(primitive::IntTy::usize()),
-                            ))),
-                        );
-                    }
-                }
-                Ty::apply_one(TypeCtor::Array, elem_ty)
-            }
-            Expr::Literal(lit) => match lit {
-                Literal::Bool(..) => Ty::simple(TypeCtor::Bool),
-                Literal::String(..) => {
-                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
-                }
-                Literal::ByteString(..) => {
-                    let byte_type = Ty::simple(TypeCtor::Int(primitive::UncertainIntTy::Known(
-                        primitive::IntTy::u8(),
-                    )));
-                    let slice_type = Ty::apply_one(TypeCtor::Slice, byte_type);
-                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type)
-                }
-                Literal::Char(..) => Ty::simple(TypeCtor::Char),
-                Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int(*ty)),
-                Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float(*ty)),
-            },
-        };
-        // use a new type variable if we got Ty::Unknown here
-        let ty = self.insert_type_vars_shallow(ty);
-        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
-        self.write_expr_ty(tgt_expr, ty.clone());
-        ty
-    }
-    fn infer_block(
-        &mut self,
-        statements: &[Statement],
-        tail: Option<ExprId>,
-        expected: &Expectation,
-    ) -> Ty {
-        let mut diverges = false;
-        for stmt in statements {
-            match stmt {
-                Statement::Let { pat, type_ref, initializer } => {
-                    let decl_ty =
-                        type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown);
-                    // Always use the declared type when specified
-                    let mut ty = decl_ty.clone();
-                    if let Some(expr) = initializer {
-                        let actual_ty =
-                            self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone()));
-                        if decl_ty == Ty::Unknown {
-                            ty = actual_ty;
-                        }
-                    }
-                    let ty = self.resolve_ty_as_possible(&mut vec![], ty);
-                    self.infer_pat(*pat, &ty, BindingMode::default());
-                }
-                Statement::Expr(expr) => {
-                    if let ty_app!(TypeCtor::Never) = self.infer_expr(*expr, &Expectation::none()) {
-                        diverges = true;
-                    }
-                }
-            }
-        }
-        let ty = if let Some(expr) = tail {
-            self.infer_expr_coerce(expr, expected)
-        } else {
-            self.coerce(&Ty::unit(), &expected.ty);
-            Ty::unit()
-        };
-        if diverges {
-            Ty::simple(TypeCtor::Never)
-        } else {
-            ty
-        }
-    }
-    fn check_call_arguments(&mut self, args: &[ExprId], param_tys: &[Ty]) {
-        // Quoting https://github.com/rust-lang/rust/blob/6ef275e6c3cb1384ec78128eceeb4963ff788dca/src/librustc_typeck/check/mod.rs#L3325 --
-        // We do this in a pretty awful way: first we type-check any arguments
-        // that are not closures, then we type-check the closures. This is so
-        // that we have more information about the types of arguments when we
-        // type-check the functions. This isn't really the right way to do this.
-        for &check_closures in &[false, true] {
-            let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown));
-            for (&arg, param_ty) in args.iter().zip(param_iter) {
-                let is_closure = match &self.body[arg] {
-                    Expr::Lambda { .. } => true,
-                    _ => false,
-                };
-                if is_closure != check_closures {
-                    continue;
-                }
-                let param_ty = self.normalize_associated_types_in(param_ty);
-                self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
-            }
-        }
-    }
    fn collect_const(&mut self, data: &ConstData) {
        self.return_ty = self.make_ty(data.type_ref());
    }
diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
new file mode 100644
index 000000000..0429a9866
--- /dev/null
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -0,0 +1,336 @@
+//! Coercion logic. Coercions are certain type conversions that can implicitly
+//! happen in certain places, e.g. weakening `&mut` to `&` or deref coercions
+//! like going from `&Vec<T>` to `&[T]`.
+//!
+//! See: https://doc.rust-lang.org/nomicon/coercions.html
+use rustc_hash::FxHashMap;
+use test_utils::tested_by;
+use super::{InferTy, InferenceContext, TypeVarValue};
+use crate::{
+    db::HirDatabase,
+    lang_item::LangItemTarget,
+    resolve::Resolver,
+    ty::{autoderef, Substs, Ty, TypeCtor, TypeWalk},
+    type_ref::Mutability,
+    Adt,
+};
+impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+    /// Unify two types, but may coerce the first one to the second one
+    /// using "implicit coercion rules" if needed.
+    pub(super) fn coerce(&mut self, from_ty: &Ty, to_ty: &Ty) -> bool {
+        let from_ty = self.resolve_ty_shallow(from_ty).into_owned();
+        let to_ty = self.resolve_ty_shallow(to_ty);
+        self.coerce_inner(from_ty, &to_ty)
+    }
+    /// Merge two types from different branches, with possible implicit coerce.
+    ///
+    /// Note that it is only possible that one type are coerced to another.
+    /// Coercing both types to another least upper bound type is not possible in rustc,
+    /// which will simply result in "incompatible types" error.
+    pub(super) fn coerce_merge_branch<'t>(&mut self, ty1: &Ty, ty2: &Ty) -> Ty {
+        if self.coerce(ty1, ty2) {
+            ty2.clone()
+        } else if self.coerce(ty2, ty1) {
+            ty1.clone()
+        } else {
+            tested_by!(coerce_merge_fail_fallback);
+            // For incompatible types, we use the latter one as result
+            // to be better recovery for `if` without `else`.
+            ty2.clone()
+        }
+    }
+    pub(super) fn init_coerce_unsized_map(
+        db: &'a D,
+        resolver: &Resolver,
+    ) -> FxHashMap<(TypeCtor, TypeCtor), usize> {
+        let krate = resolver.krate().unwrap();
+        let impls = match db.lang_item(krate, "coerce_unsized".into()) {
+            Some(LangItemTarget::Trait(trait_)) => db.impls_for_trait(krate, trait_),
+            _ => return FxHashMap::default(),
+        };
+        impls
+            .iter()
+            .filter_map(|impl_block| {
+                // `CoerseUnsized` has one generic parameter for the target type.
+                let trait_ref = impl_block.target_trait_ref(db)?;
+                let cur_from_ty = trait_ref.substs.0.get(0)?;
+                let cur_to_ty = trait_ref.substs.0.get(1)?;
+                match (&cur_from_ty, cur_to_ty) {
+                    (ty_app!(ctor1, st1), ty_app!(ctor2, st2)) => {
+                        // FIXME: We return the first non-equal bound as the type parameter to coerce to unsized type.
+                        // This works for smart-pointer-like coercion, which covers all impls from std.
+                        st1.iter().zip(st2.iter()).enumerate().find_map(|(i, (ty1, ty2))| {
+                            match (ty1, ty2) {
+                                (Ty::Param { idx: p1, .. }, Ty::Param { idx: p2, .. })
+                                    if p1 != p2 =>
+                                {
+                                    Some(((*ctor1, *ctor2), i))
+                                }
+                                _ => None,
+                            }
+                        })
+                    }
+                    _ => None,
+                }
+            })
+            .collect()
+    }
+    fn coerce_inner(&mut self, mut from_ty: Ty, to_ty: &Ty) -> bool {
+        match (&from_ty, to_ty) {
+            // Never type will make type variable to fallback to Never Type instead of Unknown.
+            (ty_app!(TypeCtor::Never), Ty::Infer(InferTy::TypeVar(tv))) => {
+                let var = self.new_maybe_never_type_var();
+                self.var_unification_table.union_value(*tv, TypeVarValue::Known(var));
+                return true;
+            }
+            (ty_app!(TypeCtor::Never), _) => return true,
+            // Trivial cases, this should go after `never` check to
+            // avoid infer result type to be never
+            _ => {
+                if self.unify_inner_trivial(&from_ty, &to_ty) {
+                    return true;
+                }
+            }
+        }
+        // Pointer weakening and function to pointer
+        match (&mut from_ty, to_ty) {
+            // `*mut T`, `&mut T, `&T`` -> `*const T`
+            // `&mut T` -> `&T`
+            // `&mut T` -> `*mut T`
+            (ty_app!(c1@TypeCtor::RawPtr(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
+            | (ty_app!(c1@TypeCtor::Ref(_)), ty_app!(c2@TypeCtor::RawPtr(Mutability::Shared)))
+            | (ty_app!(c1@TypeCtor::Ref(_)), ty_app!(c2@TypeCtor::Ref(Mutability::Shared)))
+            | (ty_app!(c1@TypeCtor::Ref(Mutability::Mut)), ty_app!(c2@TypeCtor::RawPtr(_))) => {
+                *c1 = *c2;
+            }
+            // Illegal mutablity conversion
+            (
+                ty_app!(TypeCtor::RawPtr(Mutability::Shared)),
+                ty_app!(TypeCtor::RawPtr(Mutability::Mut)),
+            )
+            | (
+                ty_app!(TypeCtor::Ref(Mutability::Shared)),
+                ty_app!(TypeCtor::Ref(Mutability::Mut)),
+            ) => return false,
+            // `{function_type}` -> `fn()`
+            (ty_app!(TypeCtor::FnDef(_)), ty_app!(TypeCtor::FnPtr { .. })) => {
+                match from_ty.callable_sig(self.db) {
+                    None => return false,
+                    Some(sig) => {
+                        let num_args = sig.params_and_return.len() as u16 - 1;
+                        from_ty =
+                            Ty::apply(TypeCtor::FnPtr { num_args }, Substs(sig.params_and_return));
+                    }
+                }
+            }
+            _ => {}
+        }
+        if let Some(ret) = self.try_coerce_unsized(&from_ty, &to_ty) {
+            return ret;
+        }
+        // Auto Deref if cannot coerce
+        match (&from_ty, to_ty) {
+            // FIXME: DerefMut
+            (ty_app!(TypeCtor::Ref(_), st1), ty_app!(TypeCtor::Ref(_), st2)) => {
+                self.unify_autoderef_behind_ref(&st1[0], &st2[0])
+            }
+            // Otherwise, normal unify
+            _ => self.unify(&from_ty, to_ty),
+        }
+    }
+    /// Coerce a type using `from_ty: CoerceUnsized<ty_ty>`
+    ///
+    /// See: https://doc.rust-lang.org/nightly/std/marker/trait.CoerceUnsized.html
+    fn try_coerce_unsized(&mut self, from_ty: &Ty, to_ty: &Ty) -> Option<bool> {
+        let (ctor1, st1, ctor2, st2) = match (from_ty, to_ty) {
+            (ty_app!(ctor1, st1), ty_app!(ctor2, st2)) => (ctor1, st1, ctor2, st2),
+            _ => return None,
+        };
+        let coerce_generic_index = *self.coerce_unsized_map.get(&(*ctor1, *ctor2))?;
+        // Check `Unsize` first
+        match self.check_unsize_and_coerce(
+            st1.0.get(coerce_generic_index)?,
+            st2.0.get(coerce_generic_index)?,
+            0,
+        ) {
+            Some(true) => {}
+            ret => return ret,
+        }
+        let ret = st1
+            .iter()
+            .zip(st2.iter())
+            .enumerate()
+            .filter(|&(idx, _)| idx != coerce_generic_index)
+            .all(|(_, (ty1, ty2))| self.unify(ty1, ty2));
+        Some(ret)
+    }
+    /// Check if `from_ty: Unsize<to_ty>`, and coerce to `to_ty` if it holds.
+    ///
+    /// It should not be directly called. It is only used by `try_coerce_unsized`.
+    ///
+    /// See: https://doc.rust-lang.org/nightly/std/marker/trait.Unsize.html
+    fn check_unsize_and_coerce(&mut self, from_ty: &Ty, to_ty: &Ty, depth: usize) -> Option<bool> {
+        if depth > 1000 {
+            panic!("Infinite recursion in coercion");
+        }
+        match (&from_ty, &to_ty) {
+            // `[T; N]` -> `[T]`
+            (ty_app!(TypeCtor::Array, st1), ty_app!(TypeCtor::Slice, st2)) => {
+                Some(self.unify(&st1[0], &st2[0]))
+            }
+            // `T` -> `dyn Trait` when `T: Trait`
+            (_, Ty::Dyn(_)) => {
+                // FIXME: Check predicates
+                Some(true)
+            }
+            // `(..., T)` -> `(..., U)` when `T: Unsize<U>`
+            (
+                ty_app!(TypeCtor::Tuple { cardinality: len1 }, st1),
+                ty_app!(TypeCtor::Tuple { cardinality: len2 }, st2),
+            ) => {
+                if len1 != len2 || *len1 == 0 {
+                    return None;
+                }
+                match self.check_unsize_and_coerce(
+                    st1.last().unwrap(),
+                    st2.last().unwrap(),
+                    depth + 1,
+                ) {
+                    Some(true) => {}
+                    ret => return ret,
+                }
+                let ret = st1[..st1.len() - 1]
+                    .iter()
+                    .zip(&st2[..st2.len() - 1])
+                    .all(|(ty1, ty2)| self.unify(ty1, ty2));
+                Some(ret)
+            }
+            // Foo<..., T, ...> is Unsize<Foo<..., U, ...>> if:
+            // - T: Unsize<U>
+            // - Foo is a struct
+            // - Only the last field of Foo has a type involving T
+            // - T is not part of the type of any other fields
+            // - Bar<T>: Unsize<Bar<U>>, if the last field of Foo has type Bar<T>
+            (
+                ty_app!(TypeCtor::Adt(Adt::Struct(struct1)), st1),
+                ty_app!(TypeCtor::Adt(Adt::Struct(struct2)), st2),
+            ) if struct1 == struct2 => {
+                let fields = struct1.fields(self.db);
+                let (last_field, prev_fields) = fields.split_last()?;
+                // Get the generic parameter involved in the last field.
+                let unsize_generic_index = {
+                    let mut index = None;
+                    let mut multiple_param = false;
+                    last_field.ty(self.db).walk(&mut |ty| match ty {
+                        &Ty::Param { idx, .. } => {
+                            if index.is_none() {
+                                index = Some(idx);
+                            } else if Some(idx) != index {
+                                multiple_param = true;
+                            }
+                        }
+                        _ => {}
+                    });
+                    if multiple_param {
+                        return None;
+                    }
+                    index?
+                };
+                // Check other fields do not involve it.
+                let mut multiple_used = false;
+                prev_fields.iter().for_each(|field| {
+                    field.ty(self.db).walk(&mut |ty| match ty {
+                        &Ty::Param { idx, .. } if idx == unsize_generic_index => {
+                            multiple_used = true
+                        }
+                        _ => {}
+                    })
+                });
+                if multiple_used {
+                    return None;
+                }
+                let unsize_generic_index = unsize_generic_index as usize;
+                // Check `Unsize` first
+                match self.check_unsize_and_coerce(
+                    st1.get(unsize_generic_index)?,
+                    st2.get(unsize_generic_index)?,
+                    depth + 1,
+                ) {
+                    Some(true) => {}
+                    ret => return ret,
+                }
+                // Then unify other parameters
+                let ret = st1
+                    .iter()
+                    .zip(st2.iter())
+                    .enumerate()
+                    .filter(|&(idx, _)| idx != unsize_generic_index)
+                    .all(|(_, (ty1, ty2))| self.unify(ty1, ty2));
+                Some(ret)
+            }
+            _ => None,
+        }
+    }
+    /// Unify `from_ty` to `to_ty` with optional auto Deref
+    ///
+    /// Note that the parameters are already stripped the outer reference.
+    fn unify_autoderef_behind_ref(&mut self, from_ty: &Ty, to_ty: &Ty) -> bool {
+        let canonicalized = self.canonicalizer().canonicalize_ty(from_ty.clone());
+        let to_ty = self.resolve_ty_shallow(&to_ty);
+        // FIXME: Auto DerefMut
+        for derefed_ty in
+            autoderef::autoderef(self.db, &self.resolver.clone(), canonicalized.value.clone())
+        {
+            let derefed_ty = canonicalized.decanonicalize_ty(derefed_ty.value);
+            match (&*self.resolve_ty_shallow(&derefed_ty), &*to_ty) {
+                // Stop when constructor matches.
+                (ty_app!(from_ctor, st1), ty_app!(to_ctor, st2)) if from_ctor == to_ctor => {
+                    // It will not recurse to `coerce`.
+                    return self.unify_substs(st1, st2, 0);
+                }
+                _ => {}
+            }
+        }
+        false
+    }
+}
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
new file mode 100644
index 000000000..f8807c742
--- /dev/null
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -0,0 +1,658 @@
+//! Type inference for expressions.
+use std::iter::{repeat, repeat_with};
+use std::sync::Arc;
+use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
+use crate::{
+    db::HirDatabase,
+    expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
+    generics::{GenericParams, HasGenericParams},
+    name,
+    nameres::Namespace,
+    path::{GenericArg, GenericArgs},
+    ty::{
+        autoderef, method_resolution, op, primitive, CallableDef, InferTy, Mutability, Obligation,
+        ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
+    },
+    Adt, Name,
+};
+impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+    pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
+        let ty = self.infer_expr_inner(tgt_expr, expected);
+        let could_unify = self.unify(&ty, &expected.ty);
+        if !could_unify {
+            self.result.type_mismatches.insert(
+                tgt_expr,
+                TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
+            );
+        }
+        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
+        ty
+    }
+    /// Infer type of expression with possibly implicit coerce to the expected type.
+    /// Return the type after possible coercion.
+    fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
+        let ty = self.infer_expr_inner(expr, &expected);
+        let ty = if !self.coerce(&ty, &expected.ty) {
+            self.result
+                .type_mismatches
+                .insert(expr, TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() });
+            // Return actual type when type mismatch.
+            // This is needed for diagnostic when return type mismatch.
+            ty
+        } else if expected.ty == Ty::Unknown {
+            ty
+        } else {
+            expected.ty.clone()
+        };
+        self.resolve_ty_as_possible(&mut vec![], ty)
+    }
+    fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
+        let body = Arc::clone(&self.body); // avoid borrow checker problem
+        let ty = match &body[tgt_expr] {
+            Expr::Missing => Ty::Unknown,
+            Expr::If { condition, then_branch, else_branch } => {
+                // if let is desugared to match, so this is always simple if
+                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
+                let then_ty = self.infer_expr_inner(*then_branch, &expected);
+                let else_ty = match else_branch {
+                    Some(else_branch) => self.infer_expr_inner(*else_branch, &expected),
+                    None => Ty::unit(),
+                };
+                self.coerce_merge_branch(&then_ty, &else_ty)
+            }
+            Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
+            Expr::TryBlock { body } => {
+                let _inner = self.infer_expr(*body, expected);
+                // FIXME should be std::result::Result<{inner}, _>
+                Ty::Unknown
+            }
+            Expr::Loop { body } => {
+                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
+                // FIXME handle break with value
+                Ty::simple(TypeCtor::Never)
+            }
+            Expr::While { condition, body } => {
+                // while let is desugared to a match loop, so this is always simple while
+                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
+                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
+                Ty::unit()
+            }
+            Expr::For { iterable, body, pat } => {
+                let iterable_ty = self.infer_expr(*iterable, &Expectation::none());
+                let pat_ty = match self.resolve_into_iter_item() {
+                    Some(into_iter_item_alias) => {
+                        let pat_ty = self.new_type_var();
+                        let projection = ProjectionPredicate {
+                            ty: pat_ty.clone(),
+                            projection_ty: ProjectionTy {
+                                associated_ty: into_iter_item_alias,
+                                parameters: Substs::single(iterable_ty),
+                            },
+                        };
+                        self.obligations.push(Obligation::Projection(projection));
+                        self.resolve_ty_as_possible(&mut vec![], pat_ty)
+                    }
+                    None => Ty::Unknown,
+                };
+                self.infer_pat(*pat, &pat_ty, BindingMode::default());
+                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
+                Ty::unit()
+            }
+            Expr::Lambda { body, args, arg_types } => {
+                assert_eq!(args.len(), arg_types.len());
+                let mut sig_tys = Vec::new();
+                for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) {
+                    let expected = if let Some(type_ref) = arg_type {
+                        self.make_ty(type_ref)
+                    } else {
+                        Ty::Unknown
+                    };
+                    let arg_ty = self.infer_pat(*arg_pat, &expected, BindingMode::default());
+                    sig_tys.push(arg_ty);
+                }
+                // add return type
+                let ret_ty = self.new_type_var();
+                sig_tys.push(ret_ty.clone());
+                let sig_ty = Ty::apply(
+                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
+                    Substs(sig_tys.into()),
+                );
+                let closure_ty = Ty::apply_one(
+                    TypeCtor::Closure { def: self.body.owner(), expr: tgt_expr },
+                    sig_ty,
+                );
+                // Eagerly try to relate the closure type with the expected
+                // type, otherwise we often won't have enough information to
+                // infer the body.
+                self.coerce(&closure_ty, &expected.ty);
+                self.infer_expr(*body, &Expectation::has_type(ret_ty));
+                closure_ty
+            }
+            Expr::Call { callee, args } => {
+                let callee_ty = self.infer_expr(*callee, &Expectation::none());
+                let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
+                    Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
+                    None => {
+                        // Not callable
+                        // FIXME: report an error
+                        (Vec::new(), Ty::Unknown)
+                    }
+                };
+                self.register_obligations_for_call(&callee_ty);
+                self.check_call_arguments(args, &param_tys);
+                let ret_ty = self.normalize_associated_types_in(ret_ty);
+                ret_ty
+            }
+            Expr::MethodCall { receiver, args, method_name, generic_args } => self
+                .infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
+            Expr::Match { expr, arms } => {
+                let input_ty = self.infer_expr(*expr, &Expectation::none());
+                let mut result_ty = self.new_maybe_never_type_var();
+                for arm in arms {
+                    for &pat in &arm.pats {
+                        let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
+                    }
+                    if let Some(guard_expr) = arm.guard {
+                        self.infer_expr(
+                            guard_expr,
+                            &Expectation::has_type(Ty::simple(TypeCtor::Bool)),
+                        );
+                    }
+                    let arm_ty = self.infer_expr_inner(arm.expr, &expected);
+                    result_ty = self.coerce_merge_branch(&result_ty, &arm_ty);
+                }
+                result_ty
+            }
+            Expr::Path(p) => {
+                // FIXME this could be more efficient...
+                let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
+                self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
+            }
+            Expr::Continue => Ty::simple(TypeCtor::Never),
+            Expr::Break { expr } => {
+                if let Some(expr) = expr {
+                    // FIXME handle break with value
+                    self.infer_expr(*expr, &Expectation::none());
+                }
+                Ty::simple(TypeCtor::Never)
+            }
+            Expr::Return { expr } => {
+                if let Some(expr) = expr {
+                    self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone()));
+                }
+                Ty::simple(TypeCtor::Never)
+            }
+            Expr::RecordLit { path, fields, spread } => {
+                let (ty, def_id) = self.resolve_variant(path.as_ref());
+                if let Some(variant) = def_id {
+                    self.write_variant_resolution(tgt_expr.into(), variant);
+                }
+                self.unify(&ty, &expected.ty);
+                let substs = ty.substs().unwrap_or_else(Substs::empty);
+                for (field_idx, field) in fields.iter().enumerate() {
+                    let field_ty = def_id
+                        .and_then(|it| match it.field(self.db, &field.name) {
+                            Some(field) => Some(field),
+                            None => {
+                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
+                                    expr: tgt_expr,
+                                    field: field_idx,
+                                });
+                                None
+                            }
+                        })
+                        .map_or(Ty::Unknown, |field| field.ty(self.db))
+                        .subst(&substs);
+                    self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
+                }
+                if let Some(expr) = spread {
+                    self.infer_expr(*expr, &Expectation::has_type(ty.clone()));
+                }
+                ty
+            }
+            Expr::Field { expr, name } => {
+                let receiver_ty = self.infer_expr(*expr, &Expectation::none());
+                let canonicalized = self.canonicalizer().canonicalize_ty(receiver_ty);
+                let ty = autoderef::autoderef(
+                    self.db,
+                    &self.resolver.clone(),
+                    canonicalized.value.clone(),
+                )
+                .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
+                    Ty::Apply(a_ty) => match a_ty.ctor {
+                        TypeCtor::Tuple { .. } => name
+                            .as_tuple_index()
+                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
+                        TypeCtor::Adt(Adt::Struct(s)) => s.field(self.db, name).map(|field| {
+                            self.write_field_resolution(tgt_expr, field);
+                            field.ty(self.db).subst(&a_ty.parameters)
+                        }),
+                        _ => None,
+                    },
+                    _ => None,
+                })
+                .unwrap_or(Ty::Unknown);
+                let ty = self.insert_type_vars(ty);
+                self.normalize_associated_types_in(ty)
+            }
+            Expr::Await { expr } => {
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                let ty = match self.resolve_future_future_output() {
+                    Some(future_future_output_alias) => {
+                        let ty = self.new_type_var();
+                        let projection = ProjectionPredicate {
+                            ty: ty.clone(),
+                            projection_ty: ProjectionTy {
+                                associated_ty: future_future_output_alias,
+                                parameters: Substs::single(inner_ty),
+                            },
+                        };
+                        self.obligations.push(Obligation::Projection(projection));
+                        self.resolve_ty_as_possible(&mut vec![], ty)
+                    }
+                    None => Ty::Unknown,
+                };
+                ty
+            }
+            Expr::Try { expr } => {
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                let ty = match self.resolve_ops_try_ok() {
+                    Some(ops_try_ok_alias) => {
+                        let ty = self.new_type_var();
+                        let projection = ProjectionPredicate {
+                            ty: ty.clone(),
+                            projection_ty: ProjectionTy {
+                                associated_ty: ops_try_ok_alias,
+                                parameters: Substs::single(inner_ty),
+                            },
+                        };
+                        self.obligations.push(Obligation::Projection(projection));
+                        self.resolve_ty_as_possible(&mut vec![], ty)
+                    }
+                    None => Ty::Unknown,
+                };
+                ty
+            }
+            Expr::Cast { expr, type_ref } => {
+                let _inner_ty = self.infer_expr(*expr, &Expectation::none());
+                let cast_ty = self.make_ty(type_ref);
+                // FIXME check the cast...
+                cast_ty
+            }
+            Expr::Ref { expr, mutability } => {
+                let expectation =
+                    if let Some((exp_inner, exp_mutability)) = &expected.ty.as_reference() {
+                        if *exp_mutability == Mutability::Mut && *mutability == Mutability::Shared {
+                            // FIXME: throw type error - expected mut reference but found shared ref,
+                            // which cannot be coerced
+                        }
+                        Expectation::has_type(Ty::clone(exp_inner))
+                    } else {
+                        Expectation::none()
+                    };
+                // FIXME reference coercions etc.
+                let inner_ty = self.infer_expr(*expr, &expectation);
+                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
+            }
+            Expr::Box { expr } => {
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                if let Some(box_) = self.resolve_boxed_box() {
+                    Ty::apply_one(TypeCtor::Adt(box_), inner_ty)
+                } else {
+                    Ty::Unknown
+                }
+            }
+            Expr::UnaryOp { expr, op } => {
+                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                match op {
+                    UnaryOp::Deref => {
+                        let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
+                        if let Some(derefed_ty) =
+                            autoderef::deref(self.db, &self.resolver, &canonicalized.value)
+                        {
+                            canonicalized.decanonicalize_ty(derefed_ty.value)
+                        } else {
+                            Ty::Unknown
+                        }
+                    }
+                    UnaryOp::Neg => {
+                        match &inner_ty {
+                            Ty::Apply(a_ty) => match a_ty.ctor {
+                                TypeCtor::Int(primitive::UncertainIntTy::Unknown)
+                                | TypeCtor::Int(primitive::UncertainIntTy::Known(
+                                    primitive::IntTy {
+                                        signedness: primitive::Signedness::Signed,
+                                        ..
+                                    },
+                                ))
+                                | TypeCtor::Float(..) => inner_ty,
+                                _ => Ty::Unknown,
+                            },
+                            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => {
+                                inner_ty
+                            }
+                            // FIXME: resolve ops::Neg trait
+                            _ => Ty::Unknown,
+                        }
+                    }
+                    UnaryOp::Not => {
+                        match &inner_ty {
+                            Ty::Apply(a_ty) => match a_ty.ctor {
+                                TypeCtor::Bool | TypeCtor::Int(_) => inner_ty,
+                                _ => Ty::Unknown,
+                            },
+                            Ty::Infer(InferTy::IntVar(..)) => inner_ty,
+                            // FIXME: resolve ops::Not trait for inner_ty
+                            _ => Ty::Unknown,
+                        }
+                    }
+                }
+            }
+            Expr::BinaryOp { lhs, rhs, op } => match op {
+                Some(op) => {
+                    let lhs_expectation = match op {
+                        BinaryOp::LogicOp(..) => Expectation::has_type(Ty::simple(TypeCtor::Bool)),
+                        _ => Expectation::none(),
+                    };
+                    let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
+                    // FIXME: find implementation of trait corresponding to operation
+                    // symbol and resolve associated `Output` type
+                    let rhs_expectation = op::binary_op_rhs_expectation(*op, lhs_ty);
+                    let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation));
+                    // FIXME: similar as above, return ty is often associated trait type
+                    op::binary_op_return_ty(*op, rhs_ty)
+                }
+                _ => Ty::Unknown,
+            },
+            Expr::Index { base, index } => {
+                let _base_ty = self.infer_expr(*base, &Expectation::none());
+                let _index_ty = self.infer_expr(*index, &Expectation::none());
+                // FIXME: use `std::ops::Index::Output` to figure out the real return type
+                Ty::Unknown
+            }
+            Expr::Tuple { exprs } => {
+                let mut tys = match &expected.ty {
+                    ty_app!(TypeCtor::Tuple { .. }, st) => st
+                        .iter()
+                        .cloned()
+                        .chain(repeat_with(|| self.new_type_var()))
+                        .take(exprs.len())
+                        .collect::<Vec<_>>(),
+                    _ => (0..exprs.len()).map(|_| self.new_type_var()).collect(),
+                };
+                for (expr, ty) in exprs.iter().zip(tys.iter_mut()) {
+                    self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
+                }
+                Ty::apply(TypeCtor::Tuple { cardinality: tys.len() as u16 }, Substs(tys.into()))
+            }
+            Expr::Array(array) => {
+                let elem_ty = match &expected.ty {
+                    ty_app!(TypeCtor::Array, st) | ty_app!(TypeCtor::Slice, st) => {
+                        st.as_single().clone()
+                    }
+                    _ => self.new_type_var(),
+                };
+                match array {
+                    Array::ElementList(items) => {
+                        for expr in items.iter() {
+                            self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
+                        }
+                    }
+                    Array::Repeat { initializer, repeat } => {
+                        self.infer_expr_coerce(
+                            *initializer,
+                            &Expectation::has_type(elem_ty.clone()),
+                        );
+                        self.infer_expr(
+                            *repeat,
+                            &Expectation::has_type(Ty::simple(TypeCtor::Int(
+                                primitive::UncertainIntTy::Known(primitive::IntTy::usize()),
+                            ))),
+                        );
+                    }
+                }
+                Ty::apply_one(TypeCtor::Array, elem_ty)
+            }
+            Expr::Literal(lit) => match lit {
+                Literal::Bool(..) => Ty::simple(TypeCtor::Bool),
+                Literal::String(..) => {
+                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
+                }
+                Literal::ByteString(..) => {
+                    let byte_type = Ty::simple(TypeCtor::Int(primitive::UncertainIntTy::Known(
+                        primitive::IntTy::u8(),
+                    )));
+                    let slice_type = Ty::apply_one(TypeCtor::Slice, byte_type);
+                    Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type)
+                }
+                Literal::Char(..) => Ty::simple(TypeCtor::Char),
+                Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int(*ty)),
+                Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float(*ty)),
+            },
+        };
+        // use a new type variable if we got Ty::Unknown here
+        let ty = self.insert_type_vars_shallow(ty);
+        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
+        self.write_expr_ty(tgt_expr, ty.clone());
+        ty
+    }
+    fn infer_block(
+        &mut self,
+        statements: &[Statement],
+        tail: Option<ExprId>,
+        expected: &Expectation,
+    ) -> Ty {
+        let mut diverges = false;
+        for stmt in statements {
+            match stmt {
+                Statement::Let { pat, type_ref, initializer } => {
+                    let decl_ty =
+                        type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown);
+                    // Always use the declared type when specified
+                    let mut ty = decl_ty.clone();
+                    if let Some(expr) = initializer {
+                        let actual_ty =
+                            self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone()));
+                        if decl_ty == Ty::Unknown {
+                            ty = actual_ty;
+                        }
+                    }
+                    let ty = self.resolve_ty_as_possible(&mut vec![], ty);
+                    self.infer_pat(*pat, &ty, BindingMode::default());
+                }
+                Statement::Expr(expr) => {
+                    if let ty_app!(TypeCtor::Never) = self.infer_expr(*expr, &Expectation::none()) {
+                        diverges = true;
+                    }
+                }
+            }
+        }
+        let ty = if let Some(expr) = tail {
+            self.infer_expr_coerce(expr, expected)
+        } else {
+            self.coerce(&Ty::unit(), &expected.ty);
+            Ty::unit()
+        };
+        if diverges {
+            Ty::simple(TypeCtor::Never)
+        } else {
+            ty
+        }
+    }
+    fn infer_method_call(
+        &mut self,
+        tgt_expr: ExprId,
+        receiver: ExprId,
+        args: &[ExprId],
+        method_name: &Name,
+        generic_args: Option<&GenericArgs>,
+    ) -> Ty {
+        let receiver_ty = self.infer_expr(receiver, &Expectation::none());
+        let canonicalized_receiver = self.canonicalizer().canonicalize_ty(receiver_ty.clone());
+        let resolved = method_resolution::lookup_method(
+            &canonicalized_receiver.value,
+            self.db,
+            method_name,
+            &self.resolver,
+        );
+        let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
+            Some((ty, func)) => {
+                let ty = canonicalized_receiver.decanonicalize_ty(ty);
+                self.write_method_resolution(tgt_expr, func);
+                (
+                    ty,
+                    self.db.type_for_def(func.into(), Namespace::Values),
+                    Some(func.generic_params(self.db)),
+                )
+            }
+            None => (receiver_ty, Ty::Unknown, None),
+        };
+        let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
+        let method_ty = method_ty.apply_substs(substs);
+        let method_ty = self.insert_type_vars(method_ty);
+        self.register_obligations_for_call(&method_ty);
+        let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
+            Some(sig) => {
+                if !sig.params().is_empty() {
+                    (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
+                } else {
+                    (Ty::Unknown, Vec::new(), sig.ret().clone())
+                }
+            }
+            None => (Ty::Unknown, Vec::new(), Ty::Unknown),
+        };
+        // Apply autoref so the below unification works correctly
+        // FIXME: return correct autorefs from lookup_method
+        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
+            Some((_, mutability)) => Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty),
+            _ => derefed_receiver_ty,
+        };
+        self.unify(&expected_receiver_ty, &actual_receiver_ty);
+        self.check_call_arguments(args, &param_tys);
+        let ret_ty = self.normalize_associated_types_in(ret_ty);
+        ret_ty
+    }
+    fn check_call_arguments(&mut self, args: &[ExprId], param_tys: &[Ty]) {
+        // Quoting https://github.com/rust-lang/rust/blob/6ef275e6c3cb1384ec78128eceeb4963ff788dca/src/librustc_typeck/check/mod.rs#L3325 --
+        // We do this in a pretty awful way: first we type-check any arguments
+        // that are not closures, then we type-check the closures. This is so
+        // that we have more information about the types of arguments when we
+        // type-check the functions. This isn't really the right way to do this.
+        for &check_closures in &[false, true] {
+            let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown));
+            for (&arg, param_ty) in args.iter().zip(param_iter) {
+                let is_closure = match &self.body[arg] {
+                    Expr::Lambda { .. } => true,
+                    _ => false,
+                };
+                if is_closure != check_closures {
+                    continue;
+                }
+                let param_ty = self.normalize_associated_types_in(param_ty);
+                self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
+            }
+        }
+    }
+    fn substs_for_method_call(
+        &mut self,
+        def_generics: Option<Arc<GenericParams>>,
+        generic_args: Option<&GenericArgs>,
+        receiver_ty: &Ty,
+    ) -> Substs {
+        let (parent_param_count, param_count) =
+            def_generics.as_ref().map_or((0, 0), |g| (g.count_parent_params(), g.params.len()));
+        let mut substs = Vec::with_capacity(parent_param_count + param_count);
+        // Parent arguments are unknown, except for the receiver type
+        if let Some(parent_generics) = def_generics.and_then(|p| p.parent_params.clone()) {
+            for param in &parent_generics.params {
+                if param.name == name::SELF_TYPE {
+                    substs.push(receiver_ty.clone());
+                } else {
+                    substs.push(Ty::Unknown);
+                }
+            }
+        }
+        // handle provided type arguments
+        if let Some(generic_args) = generic_args {
+            // if args are provided, it should be all of them, but we can't rely on that
+            for arg in generic_args.args.iter().take(param_count) {
+                match arg {
+                    GenericArg::Type(type_ref) => {
+                        let ty = self.make_ty(type_ref);
+                        substs.push(ty);
+                    }
+                }
+            }
+        };
+        let supplied_params = substs.len();
+        for _ in supplied_params..parent_param_count + param_count {
+            substs.push(Ty::Unknown);
+        }
+        assert_eq!(substs.len(), parent_param_count + param_count);
+        Substs(substs.into())
+    }
+    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
+        if let Ty::Apply(a_ty) = callable_ty {
+            if let TypeCtor::FnDef(def) = a_ty.ctor {
+                let generic_predicates = self.db.generic_predicates(def.into());
+                for predicate in generic_predicates.iter() {
+                    let predicate = predicate.clone().subst(&a_ty.parameters);
+                    if let Some(obligation) = Obligation::from_predicate(predicate) {
+                        self.obligations.push(obligation);
+                    }
+                }
+                // add obligation for trait implementation, if this is a trait method
+                match def {
+                    CallableDef::Function(f) => {
+                        if let Some(trait_) = f.parent_trait(self.db) {
+                            // construct a TraitDef
+                            let substs = a_ty.parameters.prefix(
+                                trait_.generic_params(self.db).count_params_including_parent(),
+                            );
+                            self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
+                        }
+                    }
+                    CallableDef::Struct(_) | CallableDef::EnumVariant(_) => {}
+                }
+            }
+        }
+    }
+}
diff --git a/crates/ra_hir/src/ty/infer/pat.rs b/crates/ra_hir/src/ty/infer/pat.rs
new file mode 100644
index 000000000..c125ddfbc
--- /dev/null
+++ b/crates/ra_hir/src/ty/infer/pat.rs
@@ -0,0 +1,180 @@
+//! Type inference for patterns.
+use std::iter::repeat;
+use std::sync::Arc;
+use test_utils::tested_by;
+use super::{BindingMode, InferenceContext};
+use crate::{
+    db::HirDatabase,
+    expr::{BindingAnnotation, Pat, PatId, RecordFieldPat},
+    ty::{Mutability, Substs, Ty, TypeCtor, TypeWalk},
+    Name, Path,
+};
+impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+    fn infer_tuple_struct_pat(
+        &mut self,
+        path: Option<&Path>,
+        subpats: &[PatId],
+        expected: &Ty,
+        default_bm: BindingMode,
+    ) -> Ty {
+        let (ty, def) = self.resolve_variant(path);
+        self.unify(&ty, expected);
+        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        for (i, &subpat) in subpats.iter().enumerate() {
+            let expected_ty = def
+                .and_then(|d| d.field(self.db, &Name::new_tuple_field(i)))
+                .map_or(Ty::Unknown, |field| field.ty(self.db))
+                .subst(&substs);
+            let expected_ty = self.normalize_associated_types_in(expected_ty);
+            self.infer_pat(subpat, &expected_ty, default_bm);
+        }
+        ty
+    }
+    fn infer_record_pat(
+        &mut self,
+        path: Option<&Path>,
+        subpats: &[RecordFieldPat],
+        expected: &Ty,
+        default_bm: BindingMode,
+        id: PatId,
+    ) -> Ty {
+        let (ty, def) = self.resolve_variant(path);
+        if let Some(variant) = def {
+            self.write_variant_resolution(id.into(), variant);
+        }
+        self.unify(&ty, expected);
+        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        for subpat in subpats {
+            let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
+            let expected_ty =
+                matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
+            let expected_ty = self.normalize_associated_types_in(expected_ty);
+            self.infer_pat(subpat.pat, &expected_ty, default_bm);
+        }
+        ty
+    }
+    pub(super) fn infer_pat(
+        &mut self,
+        pat: PatId,
+        mut expected: &Ty,
+        mut default_bm: BindingMode,
+    ) -> Ty {
+        let body = Arc::clone(&self.body); // avoid borrow checker problem
+        let is_non_ref_pat = match &body[pat] {
+            Pat::Tuple(..)
+            | Pat::TupleStruct { .. }
+            | Pat::Record { .. }
+            | Pat::Range { .. }
+            | Pat::Slice { .. } => true,
+            // FIXME: Path/Lit might actually evaluate to ref, but inference is unimplemented.
+            Pat::Path(..) | Pat::Lit(..) => true,
+            Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
+        };
+        if is_non_ref_pat {
+            while let Some((inner, mutability)) = expected.as_reference() {
+                expected = inner;
+                default_bm = match default_bm {
+                    BindingMode::Move => BindingMode::Ref(mutability),
+                    BindingMode::Ref(Mutability::Shared) => BindingMode::Ref(Mutability::Shared),
+                    BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(mutability),
+                }
+            }
+        } else if let Pat::Ref { .. } = &body[pat] {
+            tested_by!(match_ergonomics_ref);
+            // When you encounter a `&pat` pattern, reset to Move.
+            // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
+            default_bm = BindingMode::Move;
+        }
+        // Lose mutability.
+        let default_bm = default_bm;
+        let expected = expected;
+        let ty = match &body[pat] {
+            Pat::Tuple(ref args) => {
+                let expectations = match expected.as_tuple() {
+                    Some(parameters) => &*parameters.0,
+                    _ => &[],
+                };
+                let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
+                let inner_tys = args
+                    .iter()
+                    .zip(expectations_iter)
+                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
+                    .collect();
+                Ty::apply(TypeCtor::Tuple { cardinality: args.len() as u16 }, Substs(inner_tys))
+            }
+            Pat::Ref { pat, mutability } => {
+                let expectation = match expected.as_reference() {
+                    Some((inner_ty, exp_mut)) => {
+                        if *mutability != exp_mut {
+                            // FIXME: emit type error?
+                        }
+                        inner_ty
+                    }
+                    _ => &Ty::Unknown,
+                };
+                let subty = self.infer_pat(*pat, expectation, default_bm);
+                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
+            }
+            Pat::TupleStruct { path: p, args: subpats } => {
+                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
+            }
+            Pat::Record { path: p, args: fields } => {
+                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
+            }
+            Pat::Path(path) => {
+                // FIXME use correct resolver for the surrounding expression
+                let resolver = self.resolver.clone();
+                self.infer_path(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
+            }
+            Pat::Bind { mode, name: _, subpat } => {
+                let mode = if mode == &BindingAnnotation::Unannotated {
+                    default_bm
+                } else {
+                    BindingMode::convert(*mode)
+                };
+                let inner_ty = if let Some(subpat) = subpat {
+                    self.infer_pat(*subpat, expected, default_bm)
+                } else {
+                    expected.clone()
+                };
+                let inner_ty = self.insert_type_vars_shallow(inner_ty);
+                let bound_ty = match mode {
+                    BindingMode::Ref(mutability) => {
+                        Ty::apply_one(TypeCtor::Ref(mutability), inner_ty.clone())
+                    }
+                    BindingMode::Move => inner_ty.clone(),
+                };
+                let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty);
+                self.write_pat_ty(pat, bound_ty);
+                return inner_ty;
+            }
+            _ => Ty::Unknown,
+        };
+        // use a new type variable if we got Ty::Unknown here
+        let ty = self.insert_type_vars_shallow(ty);
+        self.unify(&ty, expected);
+        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
+        self.write_pat_ty(pat, ty.clone());
+        ty
+    }
+}
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index d161aa6b3..014c7981f 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -6,6 +6,7 @@ use crate::ty::{
    Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
    TypeWalk,
 };
+use crate::util::make_mut_slice;
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    pub(super) fn canonicalizer<'b>(&'b mut self) -> Canonicalizer<'a, 'b, D>
@@ -74,10 +75,11 @@ where
        })
    }
-    fn do_canonicalize_trait_ref(&mut self, trait_ref: TraitRef) -> TraitRef {
+    fn do_canonicalize_trait_ref(&mut self, mut trait_ref: TraitRef) -> TraitRef {
-        let substs =
+        for ty in make_mut_slice(&mut trait_ref.substs.0) {
-            trait_ref.substs.iter().map(|ty| self.do_canonicalize_ty(ty.clone())).collect();
+            *ty = self.do_canonicalize_ty(ty.clone());
-        TraitRef { trait_: trait_ref.trait_, substs: Substs(substs) }
+        }
+        trait_ref
    }
    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
@@ -87,10 +89,11 @@ where
        }
    }
-    fn do_canonicalize_projection_ty(&mut self, projection_ty: ProjectionTy) -> ProjectionTy {
+    fn do_canonicalize_projection_ty(&mut self, mut projection_ty: ProjectionTy) -> ProjectionTy {
-        let params =
+        for ty in make_mut_slice(&mut projection_ty.parameters.0) {
-            projection_ty.parameters.iter().map(|ty| self.do_canonicalize_ty(ty.clone())).collect();
+            *ty = self.do_canonicalize_ty(ty.clone());
-        ProjectionTy { associated_ty: projection_ty.associated_ty, parameters: Substs(params) }
+        }
+        projection_ty
    }
    fn do_canonicalize_projection_predicate(
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index a604c02e2..366556134 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -22,6 +22,7 @@ use crate::{
    resolve::{Resolver, TypeNs},
    ty::Adt,
    type_ref::{TypeBound, TypeRef},
+    util::make_mut_slice,
    BuiltinType, Const, Enum, EnumVariant, Function, ModuleDef, Path, Static, Struct, StructField,
    Trait, TypeAlias, Union,
 };
@@ -31,11 +32,11 @@ impl Ty {
        match type_ref {
            TypeRef::Never => Ty::simple(TypeCtor::Never),
            TypeRef::Tuple(inner) => {
-                let inner_tys =
+                let inner_tys: Arc<[Ty]> =
-                    inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
+                    inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect();
                Ty::apply(
                    TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
-                    Substs(inner_tys.into()),
+                    Substs(inner_tys),
                )
            }
            TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
@@ -57,9 +58,7 @@ impl Ty {
            }
            TypeRef::Placeholder => Ty::Unknown,
            TypeRef::Fn(params) => {
-                let inner_tys =
+                let sig = Substs(params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect());
-                    params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
-                let sig = Substs(inner_tys.into());
                Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
            }
            TypeRef::DynTrait(bounds) => {
@@ -69,8 +68,8 @@ impl Ty {
                    .flat_map(|b| {
                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
                    })
-                    .collect::<Vec<_>>();
+                    .collect();
-                Ty::Dyn(predicates.into())
+                Ty::Dyn(predicates)
            }
            TypeRef::ImplTrait(bounds) => {
                let self_ty = Ty::Bound(0);
@@ -79,8 +78,8 @@ impl Ty {
                    .flat_map(|b| {
                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
                    })
-                    .collect::<Vec<_>>();
+                    .collect();
-                Ty::Opaque(predicates.into())
+                Ty::Opaque(predicates)
            }
            TypeRef::Error => Ty::Unknown,
        }
@@ -392,10 +391,7 @@ impl TraitRef {
    ) -> Self {
        let mut substs = TraitRef::substs_from_path(db, resolver, segment, resolved);
        if let Some(self_ty) = explicit_self_ty {
-            // FIXME this could be nicer
+            make_mut_slice(&mut substs.0)[0] = self_ty;
-            let mut substs_vec = substs.0.to_vec();
-            substs_vec[0] = self_ty;
-            substs.0 = substs_vec.into();
        }
        TraitRef { trait_: resolved, substs }
    }
@@ -558,13 +554,12 @@ pub(crate) fn generic_predicates_for_param_query(
    param_idx: u32,
 ) -> Arc<[GenericPredicate]> {
    let resolver = def.resolver(db);
-    let predicates = resolver
+    resolver
        .where_predicates_in_scope()
        // we have to filter out all other predicates *first*, before attempting to lower them
        .filter(|pred| Ty::from_hir_only_param(db, &resolver, &pred.type_ref) == Some(param_idx))
        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .collect::<Vec<_>>();
+        .collect()
-    predicates.into()
 }
 pub(crate) fn trait_env(
@@ -585,11 +580,10 @@ pub(crate) fn generic_predicates_query(
    def: GenericDef,
 ) -> Arc<[GenericPredicate]> {
    let resolver = def.resolver(db);
-    let predicates = resolver
+    resolver
        .where_predicates_in_scope()
        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .collect::<Vec<_>>();
+        .collect()
-    predicates.into()
 }
 /// Resolve the default type params from generics
@@ -603,9 +597,9 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) ->
        .map(|p| {
            p.default.as_ref().map_or(Ty::Unknown, |path| Ty::from_hir_path(db, &resolver, path))
        })
-        .collect::<Vec<_>>();
+        .collect();
-    Substs(defaults.into())
+    Substs(defaults)
 }
 fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index b0f67ae50..0cb5c3798 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -89,7 +89,7 @@ pub(crate) fn impls_for_trait_query(
    }
    let crate_impl_blocks = db.impls_in_crate(krate);
    impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_));
-    impls.into_iter().collect::<Vec<_>>().into()
+    impls.into_iter().collect()
 }
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 9168de709..00aaf65d9 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -126,8 +126,7 @@ impl ToChalk for Substs {
                chalk_ir::Parameter(chalk_ir::ParameterKind::Ty(ty)) => from_chalk(db, ty),
                chalk_ir::Parameter(chalk_ir::ParameterKind::Lifetime(_)) => unimplemented!(),
            })
-            .collect::<Vec<_>>()
+            .collect();
-            .into();
        Substs(tys)
    }
 }
diff --git a/crates/ra_hir/src/type_alias.rs b/crates/ra_hir/src/type_alias.rs
index 3b38c4740..674a46102 100644
--- a/crates/ra_hir/src/type_alias.rs
+++ b/crates/ra_hir/src/type_alias.rs
@@ -17,12 +17,14 @@ pub struct TypeAliasData {
    pub(crate) type_ref: Option<TypeRef>,
 }
-pub(crate) fn type_alias_data_query(
+impl TypeAliasData {
-    db: &(impl DefDatabase + AstDatabase),
+    pub(crate) fn type_alias_data_query(
-    typ: TypeAlias,
+        db: &(impl DefDatabase + AstDatabase),
-) -> Arc<TypeAliasData> {
+        typ: TypeAlias,
-    let node = typ.source(db).ast;
+    ) -> Arc<TypeAliasData> {
-    let name = node.name().map_or_else(Name::missing, |n| n.as_name());
+        let node = typ.source(db).ast;
-    let type_ref = node.type_ref().map(TypeRef::from_ast);
+        let name = node.name().map_or_else(Name::missing, |n| n.as_name());
-    Arc::new(TypeAliasData { name, type_ref })
+        let type_ref = node.type_ref().map(TypeRef::from_ast);
+        Arc::new(TypeAliasData { name, type_ref })
+    }
 }
diff --git a/crates/ra_hir/src/util.rs b/crates/ra_hir/src/util.rs
new file mode 100644
index 000000000..0095ee45d
--- /dev/null
+++ b/crates/ra_hir/src/util.rs
@@ -0,0 +1,12 @@
+//! Internal utility functions.
+use std::sync::Arc;
+/// Helper for mutating `Arc<[T]>` (i.e. `Arc::make_mut` for Arc slices).
+/// The underlying values are cloned if there are other strong references.
+pub(crate) fn make_mut_slice<T: Clone>(a: &mut Arc<[T]>) -> &mut [T] {
+    if Arc::get_mut(a).is_none() {
+        *a = a.iter().cloned().collect();
+    }
+    Arc::get_mut(a).unwrap()
+}
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 09913787b..050249c0e 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -4,7 +4,7 @@ use std::{fmt, sync::Arc, time};
 use ra_db::{
    salsa::{Database, Durability, SweepStrategy},
-    CrateGraph, CrateId, FileId, SourceDatabase, SourceRoot, SourceRootId,
+    CrateGraph, CrateId, FileId, SourceDatabase, SourceDatabaseExt, SourceRoot, SourceRootId,
 };
 use ra_prof::{memory_usage, profile, Bytes};
 use ra_syntax::SourceFile;
diff --git a/crates/ra_ide_api/src/db.rs b/crates/ra_ide_api/src/db.rs
index ea0714add..bbf04bcf7 100644
--- a/crates/ra_ide_api/src/db.rs
+++ b/crates/ra_ide_api/src/db.rs
@@ -4,8 +4,10 @@ use std::sync::Arc;
 use ra_db::{
    salsa::{self, Database, Durability},
-    Canceled, CheckCanceled, CrateId, FileId, SourceDatabase, SourceRootId,
+    Canceled, CheckCanceled, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase,
+    SourceDatabaseExt, SourceRootId,
 };
+use relative_path::RelativePath;
 use rustc_hash::FxHashMap;
 use crate::{
@@ -15,6 +17,7 @@ use crate::{
 #[salsa::database(
    ra_db::SourceDatabaseStorage,
+    ra_db::SourceDatabaseExtStorage,
    LineIndexDatabaseStorage,
    symbol_index::SymbolsDatabaseStorage,
    hir::db::InternDatabaseStorage,
@@ -31,6 +34,22 @@ pub(crate) struct RootDatabase {
    pub(crate) last_gc_check: crate::wasm_shims::Instant,
 }
+impl FileLoader for RootDatabase {
+    fn file_text(&self, file_id: FileId) -> Arc<String> {
+        FileLoaderDelegate(self).file_text(file_id)
+    }
+    fn resolve_relative_path(
+        &self,
+        anchor: FileId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
+    }
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+        FileLoaderDelegate(self).relevant_crates(file_id)
+    }
+}
 impl hir::debug::HirDebugHelper for RootDatabase {
    fn crate_name(&self, krate: CrateId) -> Option<String> {
        self.debug_data.crate_names.get(&krate).cloned()
@@ -104,7 +123,7 @@ pub(crate) trait LineIndexDatabase: ra_db::SourceDatabase + CheckCanceled {
    fn line_index(&self, file_id: FileId) -> Arc<LineIndex>;
 }
-fn line_index(db: &impl ra_db::SourceDatabase, file_id: FileId) -> Arc<LineIndex> {
+fn line_index(db: &impl LineIndexDatabase, file_id: FileId) -> Arc<LineIndex> {
    let text = db.file_text(file_id);
    Arc::new(LineIndex::new(&*text))
 }
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index 65f061443..8743a3a79 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -4,7 +4,7 @@ use std::cell::RefCell;
 use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
 use itertools::Itertools;
-use ra_db::SourceDatabase;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_prof::profile;
 use ra_syntax::{
    algo,
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 2d92fe1c5..f7fd42f65 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -52,7 +52,7 @@ use std::sync::Arc;
 use ra_cfg::CfgOptions;
 use ra_db::{
    salsa::{self, ParallelDatabase},
-    CheckCanceled, SourceDatabase,
+    CheckCanceled, FileLoader, SourceDatabase,
 };
 use ra_syntax::{SourceFile, TextRange, TextUnit};
 use ra_text_edit::TextEdit;
@@ -289,10 +289,14 @@ impl AnalysisHost {
    pub fn per_query_memory_usage(&mut self) -> Vec<(String, ra_prof::Bytes)> {
        self.db.per_query_memory_usage()
    }
-    pub fn raw_database(&self) -> &(impl hir::db::HirDatabase + salsa::Database) {
+    pub fn raw_database(
+        &self,
+    ) -> &(impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
        &self.db
    }
-    pub fn raw_database_mut(&mut self) -> &mut (impl hir::db::HirDatabase + salsa::Database) {
+    pub fn raw_database_mut(
+        &mut self,
+    ) -> &mut (impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
        &mut self.db
    }
 }
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index c95c47bf1..4247c6d90 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 use hir::{Either, ModuleSource};
-use ra_db::SourceDatabase;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode};
 use relative_path::{RelativePath, RelativePathBuf};
diff --git a/crates/ra_ide_api/src/symbol_index.rs b/crates/ra_ide_api/src/symbol_index.rs
index 797e9926f..5729eb5b3 100644
--- a/crates/ra_ide_api/src/symbol_index.rs
+++ b/crates/ra_ide_api/src/symbol_index.rs
@@ -29,7 +29,7 @@ use std::{
 use fst::{self, Streamer};
 use ra_db::{
    salsa::{self, ParallelDatabase},
-    SourceDatabase, SourceRootId,
+    SourceDatabaseExt, SourceRootId,
 };
 use ra_syntax::{
    ast::{self, NameOwner},
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index aedc55a95..46a0f958c 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -18,8 +18,6 @@ parking_lot = "0.9.0"
 jod-thread = "0.1.0"
 ra_vfs = "0.4.0"
 ra_syntax = { path = "../ra_syntax" }
-ra_db = { path = "../ra_db" }
-ra_cfg = { path = "../ra_cfg" }
 ra_text_edit = { path = "../ra_text_edit" }
 ra_ide_api = { path = "../ra_ide_api" }
 lsp-server = "0.2.0"
diff --git a/crates/ra_mbe/Cargo.toml b/crates/ra_mbe/Cargo.toml
index b058dde91..e8ef2457b 100644
--- a/crates/ra_mbe/Cargo.toml
+++ b/crates/ra_mbe/Cargo.toml
@@ -8,7 +8,6 @@ authors = ["rust-analyzer developers"]
 ra_syntax = { path = "../ra_syntax" }
 ra_parser = { path = "../ra_parser" }
 tt = { path = "../ra_tt", package = "ra_tt" }
-itertools = "0.8.0"
 rustc-hash = "1.0.0"
 smallvec = "0.6.9"
 log = "0.4.5"
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 9bc85404a..68c594202 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -15,6 +15,7 @@ rustc-hash = "1.0.1"
 arrayvec = "0.4.10"
 once_cell = "1.2.0"
+# This crate transitively depends on `smol_str` via `rowan`.
 # ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
 # to reduce number of compilations
 smol_str = { version = "0.1.12", features = ["serde"] }
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 03f3b5fbb..ea92284b8 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -15,7 +15,7 @@ use crate::{
    },
    AstToken, Direction, InsertPosition, SmolStr, SyntaxElement,
    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
-    SyntaxNode, T,
+    SyntaxNode, SyntaxToken, T,
 };
 impl ast::FnDef {
@@ -231,12 +231,64 @@ pub fn replace_descendants<N: AstNode, D: AstNode>(
    N::cast(new_syntax).unwrap()
 }
-// Note this is copy-pasted from fmt. It seems like fmt should be a separate
+#[derive(Debug, Clone, Copy)]
-// crate, but basic tree building should be this crate. However, tree building
+pub struct IndentLevel(pub u8);
-// might want to call into fmt...
+impl From<u8> for IndentLevel {
+    fn from(level: u8) -> IndentLevel {
+        IndentLevel(level)
+    }
+}
+impl IndentLevel {
+    pub fn from_node(node: &SyntaxNode) -> IndentLevel {
+        let first_token = match node.first_token() {
+            Some(it) => it,
+            None => return IndentLevel(0),
+        };
+        for ws in prev_tokens(first_token).filter_map(ast::Whitespace::cast) {
+            let text = ws.syntax().text();
+            if let Some(pos) = text.rfind('\n') {
+                let level = text[pos + 1..].chars().count() / 4;
+                return IndentLevel(level as u8);
+            }
+        }
+        IndentLevel(0)
+    }
+    pub fn increase_indent<N: AstNode>(self, node: N) -> N {
+        N::cast(self._increase_indent(node.syntax().clone())).unwrap()
+    }
+    fn _increase_indent(self, node: SyntaxNode) -> SyntaxNode {
+        let replacements: FxHashMap<SyntaxElement, SyntaxElement> = node
+            .descendants_with_tokens()
+            .filter_map(|el| el.into_token())
+            .filter_map(ast::Whitespace::cast)
+            .filter(|ws| {
+                let text = ws.syntax().text();
+                text.contains('\n')
+            })
+            .map(|ws| {
+                (
+                    ws.syntax().clone().into(),
+                    make::tokens::whitespace(&format!(
+                        "{}{:width$}",
+                        ws.syntax().text(),
+                        "",
+                        width = self.0 as usize * 4
+                    ))
+                    .into(),
+                )
+            })
+            .collect();
+        algo::replace_descendants(&node, &replacements)
+    }
+}
+// FIXME: replace usages with IndentLevel above
 fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
-    let prev_tokens = std::iter::successors(node.first_token(), |token| token.prev_token());
+    for token in prev_tokens(node.first_token()?) {
-    for token in prev_tokens {
        if let Some(ws) = ast::Whitespace::cast(token.clone()) {
            let ws_text = ws.text();
            if let Some(pos) = ws_text.rfind('\n') {
@@ -250,6 +302,10 @@ fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
    None
 }
+fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
+    iter::successors(Some(token), |token| token.prev_token())
+}
 #[must_use]
 fn insert_children<N: AstNode>(
    parent: &N,
@@ -269,3 +325,26 @@ fn replace_children<N: AstNode>(
    let new_syntax = algo::replace_children(parent.syntax(), to_replace, &mut to_insert);
    N::cast(new_syntax).unwrap()
 }
+#[test]
+fn test_increase_indent() {
+    let arm_list = {
+        let arm = make::match_arm(iter::once(make::placeholder_pat().into()), make::expr_unit());
+        make::match_arm_list(vec![arm.clone(), arm].into_iter())
+    };
+    assert_eq!(
+        arm_list.syntax().to_string(),
+        "{
+    _ => (),
+    _ => (),
+}"
+    );
+    let indented = IndentLevel(2).increase_indent(arm_list);
+    assert_eq!(
+        indented.syntax().to_string(),
+        "{
+            _ => (),
+            _ => (),
+        }"
+    );
+}
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 287a40bee..143835172 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -160,6 +160,12 @@ pub mod tokens {
            .unwrap()
    }
+    pub fn whitespace(text: &str) -> SyntaxToken {
+        assert!(text.trim().is_empty());
+        let sf = SourceFile::parse(text).ok().unwrap();
+        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
+    }
    pub fn single_newline() -> SyntaxToken {
        SOURCE_FILE
            .tree()
diff --git a/crates/ra_tt/Cargo.toml b/crates/ra_tt/Cargo.toml
index 3328d312f..3fcc7f085 100644
--- a/crates/ra_tt/Cargo.toml
+++ b/crates/ra_tt/Cargo.toml
@@ -5,4 +5,6 @@ version = "0.1.0"
 authors = ["rust-analyzer developers"]
 [dependencies]
-smol_str = "0.1.9"
+# ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
+# to reduce number of compilations
+smol_str = { version = "0.1.12", features = ["serde"] }
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 0db3e731e..5e18e4ffe 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -14,7 +14,7 @@ To learn more about how rust-analyzer works, see
 We also publish rustdoc docs to pages:
-https://rust-analyzer.github.io/rust-analyzer/ra_ide_api/index.html
+https://rust-analyzer.github.io/rust-analyzer/api-docs/ra_ide_api/
 Various organizational and process issues are discussed in this document.