209 files changed, 11023 insertions, 10257 deletions
diff --git a/.cargo/config b/.cargo/config
index 92a3acfd0..9f9b24a49 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -5,6 +5,8 @@ gen-syntax   = "run --package ra_tools --bin ra_tools -- gen-syntax"
 # Extracts the tests from
 gen-tests    = "run --package ra_tools --bin ra_tools -- gen-tests"
+build-website = "run --package website-gen"
 # Installs the visual studio code extension
 install-ra   = "run --package ra_tools --bin ra_tools -- install-ra"
 install-code = "run --package ra_tools --bin ra_tools -- install-ra" # just an alias
diff --git a/.travis.yml b/.travis.yml
index 52af05375..c198cc5f7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -28,7 +28,7 @@ matrix:
          language: rust
          rust: stable
          script:
-              - cargo doc --all --no-deps
+              - cargo build-website
          env:
              - RUSTFLAGS="-D warnings", CARGO_INCREMENTAL=0
@@ -59,7 +59,7 @@ deploy:
    skip-cleanup: true
    github-token: $DOCS_TOKEN  # Set in the settings page of your repository, as a secure variable
    keep-history: true
-    local-dir: target/doc
+    local-dir: target/website/
    on:
        branch: master
        condition: $DEPLOY_DOCS = 1
diff --git a/Cargo.lock b/Cargo.lock
index 9c630f370..27e0a82af 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -122,7 +122,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "chalk-engine"
 version = "0.9.0"
-source = "git+https://github.com/rust-lang/chalk.git#c9314e425e49969c33cabcb8fac7da6eac3c5073"
+source = "git+https://github.com/rust-lang/chalk.git#5c6cea8bc02c8bc282223aa12528648b5cd0b6e4"
 dependencies = [
 "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -132,7 +132,7 @@ dependencies = [
 [[package]]
 name = "chalk-ir"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git#c9314e425e49969c33cabcb8fac7da6eac3c5073"
+source = "git+https://github.com/rust-lang/chalk.git#5c6cea8bc02c8bc282223aa12528648b5cd0b6e4"
 dependencies = [
 "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)",
 "chalk-macros 0.1.1 (git+https://github.com/rust-lang/chalk.git)",
@@ -142,7 +142,7 @@ dependencies = [
 [[package]]
 name = "chalk-macros"
 version = "0.1.1"
-source = "git+https://github.com/rust-lang/chalk.git#c9314e425e49969c33cabcb8fac7da6eac3c5073"
+source = "git+https://github.com/rust-lang/chalk.git#5c6cea8bc02c8bc282223aa12528648b5cd0b6e4"
 dependencies = [
 "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -150,7 +150,7 @@ dependencies = [
 [[package]]
 name = "chalk-rust-ir"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git#c9314e425e49969c33cabcb8fac7da6eac3c5073"
+source = "git+https://github.com/rust-lang/chalk.git#5c6cea8bc02c8bc282223aa12528648b5cd0b6e4"
 dependencies = [
 "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)",
 "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
@@ -160,7 +160,7 @@ dependencies = [
 [[package]]
 name = "chalk-solve"
 version = "0.1.0"
-source = "git+https://github.com/rust-lang/chalk.git#c9314e425e49969c33cabcb8fac7da6eac3c5073"
+source = "git+https://github.com/rust-lang/chalk.git#5c6cea8bc02c8bc282223aa12528648b5cd0b6e4"
 dependencies = [
 "chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)",
 "chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)",
@@ -665,7 +665,7 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.60.0"
+version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -800,11 +800,8 @@ dependencies = [
 [[package]]
 name = "once_cell"
-version = "0.2.7"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
 [[package]]
 name = "ordermap"
@@ -950,7 +947,7 @@ dependencies = [
 "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 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "once_cell 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_db 0.1.0",
 "ra_fmt 0.1.0",
 "ra_hir 0.1.0",
@@ -1020,7 +1017,7 @@ dependencies = [
 "insta 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lalrpop-intern 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "once_cell 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "once_cell 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_arena 0.1.0",
 "ra_db 0.1.0",
@@ -1069,7 +1066,7 @@ dependencies = [
 "jod-thread 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "lsp-server 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "lsp-types 0.60.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_ide_api 0.1.0",
 "ra_prof 0.1.0",
@@ -1115,7 +1112,7 @@ dependencies = [
 "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jemalloc-ctl 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "jemallocator 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "once_cell 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "once_cell 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@@ -1780,6 +1777,13 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
+name = "website-gen"
+version = "0.0.0"
+dependencies = [
+ "walkdir 2.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
 name = "winapi"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1920,7 +1924,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum lock_api 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f8912e782533a93a167888781b836336a6ca5da6175c05944c86cf28c31104dc"
 "checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
 "checksum lsp-server 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "148cfb1c0b3295c23d9fb4a20fd1b242f5e6f46c525fdcc7f5c0a65710362012"
-"checksum lsp-types 0.60.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fe3edefcd66dde1f7f1df706f46520a3c93adc5ca4bc5747da6621195e894efd"
+"checksum lsp-types 0.61.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fa3268fbe8beb2795c2fb327bf44f4f3d24f5fe9ebc18d7e2980afd444d72bcf"
 "checksum matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
 "checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e"
 "checksum memoffset 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ce6075db033bbbb7ee5a0bbd3a3186bbae616f57fb001c485c7ff77955f8177f"
@@ -1934,7 +1938,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "6ba9a427cfca2be13aa6f6403b0b7e7368fe982bfa16fccc450ce74c46cd9b32"
 "checksum num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcef43580c035376c0705c42792c294b66974abbfd2789b511784023f71f3273"
 "checksum number_prefix 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dbf9993e59c894e3c08aa1c2712914e9e6bf1fcbfc6bef283e2183df345a4fee"
-"checksum once_cell 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1d1a13503127ae8c93c0e2c817d74895b0af4df9132ec9be3ea42dd1656cd6e9"
+"checksum once_cell 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c9192c5a4c3b5488dae8d3886ef9df6b5eb246d36323dc7a5078595a154e7771"
 "checksum ordermap 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "a86ed3f5f244b372d6b1a00b72ef7f8876d0bc6a78a4c9985c53614041512063"
 "checksum parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252"
 "checksum parking_lot_core 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b876b1b9e7ac6e1a74a6da34d25c42e17e8862aa409cbbbdcfc8d86c6f3bc62b"
diff --git a/Cargo.toml b/Cargo.toml
index e44c9570f..317c63795 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = [ "crates/*" ]
+members = [ "crates/*", "website/website-gen" ]
 [profile.release]
 incremental = true
diff --git a/README.md b/README.md
index e8f0e953e..50918ee5e 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Frls-2.2E0
 ## Quick Links
 * Work List: https://paper.dropbox.com/doc/RLS-2.0-work-list--AZ3BgHKKCtqszbsi3gi6sjchAQ-42vbnxzuKq2lKwW0mkn8Y
-* API docs: https://rust-analyzer.github.io/rust-analyzer/ra_ide_api/index.html
+* API docs: https://rust-analyzer.github.io/rust-analyzer/api-docs/ra_ide_api/
 * CI: https://travis-ci.org/rust-analyzer/rust-analyzer
 ## License
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 2113286a3..635d87611 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 format-buf = "1.0.0"
-once_cell = "0.2.0"
+once_cell = "1.0.1"
 join_to_string = "0.1.3"
 itertools = "0.8.0"
 arrayvec = "0.4.10"
diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
index 6815638dc..048478662 100644
--- a/crates/ra_assists/src/ast_editor.rs
+++ b/crates/ra_assists/src/ast_editor.rs
@@ -274,7 +274,7 @@ impl AstBuilder<ast::Block> {
 impl AstBuilder<ast::Expr> {
    fn from_text(text: &str) -> ast::Expr {
-        ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
+        ast_node_from_file_text(&format!("const C: () = {};", text))
    }
    pub fn unit() -> ast::Expr {
diff --git a/crates/ra_assists/src/introduce_variable.rs b/crates/ra_assists/src/introduce_variable.rs
index 95c18d0e3..470ffe120 100644
--- a/crates/ra_assists/src/introduce_variable.rs
+++ b/crates/ra_assists/src/introduce_variable.rs
@@ -3,7 +3,8 @@ use hir::db::HirDatabase;
 use ra_syntax::{
    ast::{self, AstNode},
    SyntaxKind::{
-        BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR, WHITESPACE,
+        BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
+        WHITESPACE,
    },
    SyntaxNode, TextUnit,
 };
@@ -80,10 +81,12 @@ pub(crate) fn introduce_variable(mut ctx: AssistCtx<impl HirDatabase>) -> Option
 /// In general that's true for any expression, but in some cases that would produce invalid code.
 fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
    match node.kind() {
-        PATH_EXPR => None,
+        PATH_EXPR | LOOP_EXPR => None,
        BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()),
        RETURN_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
-        LOOP_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
+        BLOCK_EXPR => {
+            ast::BlockExpr::cast(node).filter(|it| it.is_standalone()).map(ast::Expr::from)
+        }
        _ => ast::Expr::cast(node),
    }
 }
diff --git a/crates/ra_assists/src/move_guard.rs b/crates/ra_assists/src/move_guard.rs
index 127c9e068..699221e33 100644
--- a/crates/ra_assists/src/move_guard.rs
+++ b/crates/ra_assists/src/move_guard.rs
@@ -65,9 +65,9 @@ pub(crate) fn move_arm_cond_to_match_guard(mut ctx: AssistCtx<impl HirDatabase>)
        "move condition to match guard",
        |edit| {
            edit.target(if_expr.syntax().text_range());
-            let then_only_expr = then_block.statements().next().is_none();
+            let then_only_expr = then_block.block().and_then(|it| it.statements().next()).is_none();
-            match &then_block.expr() {
+            match &then_block.block().and_then(|it| it.expr()) {
                Some(then_expr) if then_only_expr => {
                    edit.replace(if_expr.syntax().text_range(), then_expr.syntax().text())
                }
diff --git a/crates/ra_assists/src/replace_if_let_with_match.rs b/crates/ra_assists/src/replace_if_let_with_match.rs
index c0bf6d235..401835c57 100644
--- a/crates/ra_assists/src/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/replace_if_let_with_match.rs
@@ -1,3 +1,4 @@
+use format_buf::format;
 use hir::db::HirDatabase;
 use ra_fmt::extract_trivial_expression;
 use ra_syntax::{ast, AstNode};
@@ -25,16 +26,21 @@ pub(crate) fn replace_if_let_with_match(mut ctx: AssistCtx<impl HirDatabase>) ->
    ctx.build()
 }
-fn build_match_expr(expr: ast::Expr, pat1: ast::Pat, arm1: ast::Block, arm2: ast::Block) -> String {
+fn build_match_expr(
+    expr: ast::Expr,
+    pat1: ast::Pat,
+    arm1: ast::BlockExpr,
+    arm2: ast::BlockExpr,
+) -> String {
    let mut buf = String::new();
-    buf.push_str(&format!("match {} {{\n", expr.syntax().text()));
+    format!(buf, "match {} {{\n", expr.syntax().text());
-    buf.push_str(&format!("    {} => {}\n", pat1.syntax().text(), format_arm(&arm1)));
+    format!(buf, "    {} => {}\n", pat1.syntax().text(), format_arm(&arm1));
-    buf.push_str(&format!("    _ => {}\n", format_arm(&arm2)));
+    format!(buf, "    _ => {}\n", format_arm(&arm2));
    buf.push_str("}");
    buf
 }
-fn format_arm(block: &ast::Block) -> String {
+fn format_arm(block: &ast::BlockExpr) -> String {
    match extract_trivial_expression(block) {
        None => block.syntax().text().to_string(),
        Some(e) => format!("{},", e.syntax().text()),
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 7e7e6c073..1fad5b233 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -1,7 +1,7 @@
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
 use ra_db::SourceDatabase;
-use ra_hir::{Crate, HasSource, ImplItem, ModuleDef, Ty};
+use ra_hir::{Crate, HasBodySource, HasSource, HirDisplay, ImplItem, ModuleDef, Ty, TypeWalk};
 use ra_syntax::AstNode;
 use crate::Result;
@@ -66,6 +66,7 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
    let mut num_exprs = 0;
    let mut num_exprs_unknown = 0;
    let mut num_exprs_partially_unknown = 0;
+    let mut num_type_mismatches = 0;
    for f in funcs {
        let name = f.name(db);
        let mut msg = format!("processing: {}", name);
@@ -100,6 +101,42 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
                    num_exprs_partially_unknown += 1;
                }
            }
+            if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
+                num_type_mismatches += 1;
+                if verbose {
+                    let src = f.expr_source(db, expr_id);
+                    if let Some(src) = src {
+                        // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
+                        let original_file = src.file_id.original_file(db);
+                        let path = db.file_relative_path(original_file);
+                        let line_index = host.analysis().file_line_index(original_file).unwrap();
+                        let text_range = src
+                            .ast
+                            .either(|it| it.syntax().text_range(), |it| it.syntax().text_range());
+                        let (start, end) = (
+                            line_index.line_col(text_range.start()),
+                            line_index.line_col(text_range.end()),
+                        );
+                        bar.println(format!(
+                            "{} {}:{}-{}:{}: Expected {}, got {}",
+                            path.display(),
+                            start.line + 1,
+                            start.col_utf16,
+                            end.line + 1,
+                            end.col_utf16,
+                            mismatch.expected.display(db),
+                            mismatch.actual.display(db)
+                        ));
+                    } else {
+                        bar.println(format!(
+                            "{}: Expected {}, got {}",
+                            name,
+                            mismatch.expected.display(db),
+                            mismatch.actual.display(db)
+                        ));
+                    }
+                }
+            }
        }
        bar.inc(1);
    }
@@ -115,6 +152,7 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
        num_exprs_partially_unknown,
        (num_exprs_partially_unknown * 100 / num_exprs)
    );
+    println!("Type mismatches: {}", num_type_mismatches);
    println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
    println!("Total: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs
index b09478d7a..e22ac9753 100644
--- a/crates/ra_fmt/src/lib.rs
+++ b/crates/ra_fmt/src/lib.rs
@@ -34,7 +34,8 @@ fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
    successors(token.prev_token(), |token| token.prev_token())
 }
-pub fn extract_trivial_expression(block: &ast::Block) -> Option<ast::Expr> {
+pub fn extract_trivial_expression(expr: &ast::BlockExpr) -> Option<ast::Expr> {
+    let block = expr.block()?;
    let expr = block.expr()?;
    if expr.syntax().text().contains_char('\n') {
        return None;
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 646c96692..d9bed4dda 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -11,7 +11,7 @@ relative-path = "0.4.0"
 rustc-hash = "1.0"
 parking_lot = "0.9.0"
 ena = "0.13"
-once_cell = "0.2"
+once_cell = "1.0.1"
 ra_syntax = { path = "../ra_syntax" }
 ra_arena = { path = "../ra_arena" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 66a58efed..f7efc1b66 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -510,18 +510,6 @@ pub enum DefWithBody {
 impl_froms!(DefWithBody: Function, Const, Static);
 impl DefWithBody {
-    pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self)
-    }
-    pub fn body(self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body_hir(self)
-    }
-    pub fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_with_source_map(self).1
-    }
    /// Builds a resolver for code inside this item.
    pub(crate) fn resolver(self, db: &impl HirDatabase) -> Resolver {
        match self {
@@ -532,6 +520,43 @@ impl DefWithBody {
    }
 }
+pub trait HasBody: Copy {
+    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult>;
+    fn body(self, db: &impl HirDatabase) -> Arc<Body>;
+    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap>;
+}
+impl<T> HasBody for T
+where
+    T: Into<DefWithBody> + Copy + HasSource,
+{
+    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer(self.into())
+    }
+    fn body(self, db: &impl HirDatabase) -> Arc<Body> {
+        db.body_hir(self.into())
+    }
+    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map(self.into()).1
+    }
+}
+impl HasBody for DefWithBody {
+    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer(self)
+    }
+    fn body(self, db: &impl HirDatabase) -> Arc<Body> {
+        db.body_hir(self)
+    }
+    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map(self).1
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Function {
    pub(crate) id: FunctionId,
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index 32bd9c661..b9ffb0c7a 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -1,11 +1,15 @@
-use ra_syntax::ast;
+use ra_syntax::{
+    ast::{self, AstNode},
+    SyntaxNode,
+};
 use crate::{
-    ids::AstItemDef, AstDatabase, Const, DefDatabase, Enum, EnumVariant, FieldSource, Function,
+    ids::AstItemDef, AstDatabase, Const, DefDatabase, Either, Enum, EnumVariant, FieldSource,
-    HirFileId, MacroDef, Module, ModuleSource, Static, Struct, StructField, Trait, TypeAlias,
+    Function, HasBody, HirDatabase, HirFileId, MacroDef, Module, ModuleSource, Static, Struct,
-    Union,
+    StructField, Trait, TypeAlias, Union,
 };
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct Source<T> {
    pub file_id: HirFileId,
    pub ast: T,
@@ -16,6 +20,15 @@ pub trait HasSource {
    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<Self::Ast>;
 }
+impl<T> Source<T> {
+    pub(crate) fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+    pub(crate) fn file_syntax(&self, db: &impl AstDatabase) -> SyntaxNode {
+        db.parse_or_expand(self.file_id).expect("source created from invalid file")
+    }
+}
 /// NB: Module is !HasSource, because it has two source nodes at the same time:
 /// definition and declaration.
 impl Module {
@@ -108,3 +121,27 @@ impl HasSource for MacroDef {
        Source { file_id: self.id.0.file_id(), ast: self.id.0.to_node(db) }
    }
 }
+pub trait HasBodySource: HasBody + HasSource
+where
+    Self::Ast: AstNode,
+{
+    fn expr_source(
+        self,
+        db: &impl HirDatabase,
+        expr_id: crate::expr::ExprId,
+    ) -> Option<Source<Either<ast::Expr, ast::RecordField>>> {
+        let source_map = self.body_source_map(db);
+        let source_ptr = source_map.expr_syntax(expr_id)?;
+        let root = source_ptr.file_syntax(db);
+        let source = source_ptr.map(|ast| ast.map(|it| it.to_node(&root), |it| it.to_node(&root)));
+        Some(source)
+    }
+}
+impl<T> HasBodySource for T
+where
+    T: HasBody + HasSource,
+    T::Ast: AstNode,
+{
+}
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 7cdc7555c..fc21e269f 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -1,36 +1,30 @@
-use std::ops::Index;
+pub(crate) mod lower;
-use std::sync::Arc;
+pub(crate) mod scope;
+pub(crate) mod validation;
-use rustc_hash::FxHashMap;
+use std::{ops::Index, sync::Arc};
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
-use ra_syntax::{
+use ra_syntax::{ast, AstPtr};
-    ast::{
+use rustc_hash::FxHashMap;
-        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
-        TryBlockBodyOwner, TypeAscriptionOwner,
-    },
-    AstNode, AstPtr, SyntaxNodePtr,
-};
-use test_utils::tested_by;
 use crate::{
-    name::{AsName, SELF_PARAM},
    path::GenericArgs,
-    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
+    ty::primitive::{UncertainFloatTy, UncertainIntTy},
    type_ref::{Mutability, TypeRef},
-    DefWithBody, Either, HasSource, HirDatabase, HirFileId, MacroCallLoc, MacroFileKind, Name,
+    DefWithBody, Either, HasSource, HirDatabase, Name, Path, Resolver, Source,
-    Path, Resolver,
 };
 pub use self::scope::ExprScopes;
-pub(crate) mod scope;
-pub(crate) mod validation;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ExprId(RawId);
 impl_arena_id!(ExprId);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PatId(RawId);
+impl_arena_id!(PatId);
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq)]
 pub struct Body {
@@ -49,22 +43,32 @@ pub struct Body {
    body_expr: ExprId,
 }
+type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;
+type ExprSource = Source<ExprPtr>;
+type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
+type PatSource = Source<PatPtr>;
 /// An item body together with the mapping from syntax nodes to HIR expression
 /// IDs. This is needed to go from e.g. a position in a file to the HIR
 /// expression containing it; but for type inference etc., we want to operate on
 /// a structure that is agnostic to the actual positions of expressions in the
 /// file, so that we don't recompute types whenever some whitespace is typed.
+///
+/// One complication here is that, due to macro expansion, a single `Body` might
+/// be spread across several files. So, for each ExprId and PatId, we record
+/// both the HirFileId and the position inside the file. However, we only store
+/// AST -> ExprId mapping for non-macro files, as it is not clear how to handle
+/// this properly for macros.
 #[derive(Default, Debug, Eq, PartialEq)]
 pub struct BodySourceMap {
-    expr_map: FxHashMap<SyntaxNodePtr, ExprId>,
+    expr_map: FxHashMap<ExprPtr, ExprId>,
-    expr_map_back: ArenaMap<ExprId, SyntaxNodePtr>,
+    expr_map_back: ArenaMap<ExprId, ExprSource>,
    pat_map: FxHashMap<PatPtr, PatId>,
-    pat_map_back: ArenaMap<PatId, PatPtr>,
+    pat_map_back: ArenaMap<PatId, PatSource>,
    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,
 }
-type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
 impl Body {
    pub fn params(&self) -> &[PatId] {
        &self.params
@@ -128,20 +132,16 @@ impl Index<PatId> for Body {
 }
 impl BodySourceMap {
-    pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option<SyntaxNodePtr> {
+    pub(crate) fn expr_syntax(&self, expr: ExprId) -> Option<ExprSource> {
-        self.expr_map_back.get(expr).cloned()
+        self.expr_map_back.get(expr).copied()
-    }
-    pub(crate) fn syntax_expr(&self, ptr: SyntaxNodePtr) -> Option<ExprId> {
-        self.expr_map.get(&ptr).cloned()
    }
    pub(crate) fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
-        self.expr_map.get(&SyntaxNodePtr::new(node.syntax())).cloned()
+        self.expr_map.get(&Either::A(AstPtr::new(node))).cloned()
    }
-    pub(crate) fn pat_syntax(&self, pat: PatId) -> Option<PatPtr> {
+    pub(crate) fn pat_syntax(&self, pat: PatId) -> Option<PatSource> {
-        self.pat_map_back.get(pat).cloned()
+        self.pat_map_back.get(pat).copied()
    }
    pub(crate) fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
@@ -436,10 +436,6 @@ impl Expr {
    }
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PatId(RawId);
-impl_arena_id!(PatId);
 /// Explicit binding annotations given in the HIR for a binding. Note
 /// that this is not the final binding *mode* that we infer after type
 /// inference.
@@ -485,7 +481,7 @@ pub enum Pat {
    Missing,
    Wild,
    Tuple(Vec<PatId>),
-    Struct {
+    Record {
        path: Option<Path>,
        args: Vec<RecordFieldPat>,
        // FIXME: 'ellipsis' option
@@ -531,7 +527,7 @@ impl Pat {
                let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter());
                total_iter.copied().for_each(f);
            }
-            Pat::Struct { args, .. } => {
+            Pat::Record { args, .. } => {
                args.iter().map(|f| f.pat).for_each(f);
            }
        }
@@ -539,624 +535,29 @@ impl Pat {
 }
 // Queries
-pub(crate) struct ExprCollector<DB> {
-    db: DB,
-    owner: DefWithBody,
-    exprs: Arena<ExprId, Expr>,
-    pats: Arena<PatId, Pat>,
-    source_map: BodySourceMap,
-    params: Vec<PatId>,
-    body_expr: Option<ExprId>,
-    resolver: Resolver,
-    // Expr collector expands macros along the way. original points to the file
-    // we started with, current points to the current macro expansion. source
-    // maps don't support macros yet, so we only record info into source map if
-    // current == original (see #1196)
-    original_file_id: HirFileId,
-    current_file_id: HirFileId,
-}
-impl<'a, DB> ExprCollector<&'a DB>
-where
-    DB: HirDatabase,
-{
-    fn new(owner: DefWithBody, file_id: HirFileId, resolver: Resolver, db: &'a DB) -> Self {
-        ExprCollector {
-            owner,
-            resolver,
-            db,
-            exprs: Arena::default(),
-            pats: Arena::default(),
-            source_map: BodySourceMap::default(),
-            params: Vec::new(),
-            body_expr: None,
-            original_file_id: file_id,
-            current_file_id: file_id,
-        }
-    }
-    fn alloc_expr(&mut self, expr: Expr, syntax_ptr: SyntaxNodePtr) -> ExprId {
-        let id = self.exprs.alloc(expr);
-        if self.current_file_id == self.original_file_id {
-            self.source_map.expr_map.insert(syntax_ptr, id);
-            self.source_map.expr_map_back.insert(id, syntax_ptr);
-        }
-        id
-    }
-    fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
-        let id = self.pats.alloc(pat);
-        if self.current_file_id == self.original_file_id {
-            self.source_map.pat_map.insert(ptr, id);
-            self.source_map.pat_map_back.insert(id, ptr);
-        }
-        id
-    }
-    fn empty_block(&mut self) -> ExprId {
-        let block = Expr::Block { statements: Vec::new(), tail: None };
-        self.exprs.alloc(block)
-    }
-    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
-        let syntax_ptr = SyntaxNodePtr::new(expr.syntax());
-        match expr {
-            ast::Expr::IfExpr(e) => {
-                let then_branch = self.collect_block_opt(e.then_branch());
-                let else_branch = e.else_branch().map(|b| match b {
-                    ast::ElseBranch::Block(it) => self.collect_block(it),
-                    ast::ElseBranch::IfExpr(elif) => {
-                        let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
-                        self.collect_expr(expr)
-                    }
-                });
-                let condition = match e.condition() {
-                    None => self.exprs.alloc(Expr::Missing),
-                    Some(condition) => match condition.pat() {
-                        None => self.collect_expr_opt(condition.expr()),
-                        // if let -- desugar to match
-                        Some(pat) => {
-                            let pat = self.collect_pat(pat);
-                            let match_expr = self.collect_expr_opt(condition.expr());
-                            let placeholder_pat = self.pats.alloc(Pat::Missing);
-                            let arms = vec![
-                                MatchArm { pats: vec![pat], expr: then_branch, guard: None },
-                                MatchArm {
-                                    pats: vec![placeholder_pat],
-                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
-                                    guard: None,
-                                },
-                            ];
-                            return self
-                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
-                        }
-                    },
-                };
-                self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
-            }
-            ast::Expr::TryBlockExpr(e) => {
-                let body = self.collect_block_opt(e.try_body());
-                self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
-            }
-            ast::Expr::BlockExpr(e) => self.collect_block_opt(e.block()),
-            ast::Expr::LoopExpr(e) => {
-                let body = self.collect_block_opt(e.loop_body());
-                self.alloc_expr(Expr::Loop { body }, syntax_ptr)
-            }
-            ast::Expr::WhileExpr(e) => {
-                let body = self.collect_block_opt(e.loop_body());
-                let condition = match e.condition() {
-                    None => self.exprs.alloc(Expr::Missing),
-                    Some(condition) => match condition.pat() {
-                        None => self.collect_expr_opt(condition.expr()),
-                        // if let -- desugar to match
-                        Some(pat) => {
-                            tested_by!(infer_while_let);
-                            let pat = self.collect_pat(pat);
-                            let match_expr = self.collect_expr_opt(condition.expr());
-                            let placeholder_pat = self.pats.alloc(Pat::Missing);
-                            let break_ = self.exprs.alloc(Expr::Break { expr: None });
-                            let arms = vec![
-                                MatchArm { pats: vec![pat], expr: body, guard: None },
-                                MatchArm { pats: vec![placeholder_pat], expr: break_, guard: None },
-                            ];
-                            let match_expr =
-                                self.exprs.alloc(Expr::Match { expr: match_expr, arms });
-                            return self.alloc_expr(Expr::Loop { body: match_expr }, syntax_ptr);
-                        }
-                    },
-                };
-                self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
-            }
-            ast::Expr::ForExpr(e) => {
-                let iterable = self.collect_expr_opt(e.iterable());
-                let pat = self.collect_pat_opt(e.pat());
-                let body = self.collect_block_opt(e.loop_body());
-                self.alloc_expr(Expr::For { iterable, pat, body }, syntax_ptr)
-            }
-            ast::Expr::CallExpr(e) => {
-                let callee = self.collect_expr_opt(e.expr());
-                let args = if let Some(arg_list) = e.arg_list() {
-                    arg_list.args().map(|e| self.collect_expr(e)).collect()
-                } else {
-                    Vec::new()
-                };
-                self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
-            }
-            ast::Expr::MethodCallExpr(e) => {
-                let receiver = self.collect_expr_opt(e.expr());
-                let args = if let Some(arg_list) = e.arg_list() {
-                    arg_list.args().map(|e| self.collect_expr(e)).collect()
-                } else {
-                    Vec::new()
-                };
-                let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let generic_args = e.type_arg_list().and_then(GenericArgs::from_ast);
-                self.alloc_expr(
-                    Expr::MethodCall { receiver, method_name, args, generic_args },
-                    syntax_ptr,
-                )
-            }
-            ast::Expr::MatchExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                let arms = if let Some(match_arm_list) = e.match_arm_list() {
-                    match_arm_list
-                        .arms()
-                        .map(|arm| MatchArm {
-                            pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
-                            expr: self.collect_expr_opt(arm.expr()),
-                            guard: arm
-                                .guard()
-                                .and_then(|guard| guard.expr())
-                                .map(|e| self.collect_expr(e)),
-                        })
-                        .collect()
-                } else {
-                    Vec::new()
-                };
-                self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
-            }
-            ast::Expr::PathExpr(e) => {
-                let path =
-                    e.path().and_then(Path::from_ast).map(Expr::Path).unwrap_or(Expr::Missing);
-                self.alloc_expr(path, syntax_ptr)
-            }
-            ast::Expr::ContinueExpr(_e) => {
-                // FIXME: labels
-                self.alloc_expr(Expr::Continue, syntax_ptr)
-            }
-            ast::Expr::BreakExpr(e) => {
-                let expr = e.expr().map(|e| self.collect_expr(e));
-                self.alloc_expr(Expr::Break { expr }, syntax_ptr)
-            }
-            ast::Expr::ParenExpr(e) => {
-                let inner = self.collect_expr_opt(e.expr());
-                // make the paren expr point to the inner expression as well
-                self.source_map.expr_map.insert(syntax_ptr, inner);
-                inner
-            }
-            ast::Expr::ReturnExpr(e) => {
-                let expr = e.expr().map(|e| self.collect_expr(e));
-                self.alloc_expr(Expr::Return { expr }, syntax_ptr)
-            }
-            ast::Expr::RecordLit(e) => {
-                let path = e.path().and_then(Path::from_ast);
-                let mut field_ptrs = Vec::new();
-                let record_lit = if let Some(nfl) = e.record_field_list() {
-                    let fields = nfl
-                        .fields()
-                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
-                        .map(|field| RecordLitField {
-                            name: field
-                                .name_ref()
-                                .map(|nr| nr.as_name())
-                                .unwrap_or_else(Name::missing),
-                            expr: if let Some(e) = field.expr() {
-                                self.collect_expr(e)
-                            } else if let Some(nr) = field.name_ref() {
-                                // field shorthand
-                                let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(&nr)));
-                                self.source_map
-                                    .expr_map
-                                    .insert(SyntaxNodePtr::new(nr.syntax()), id);
-                                self.source_map
-                                    .expr_map_back
-                                    .insert(id, SyntaxNodePtr::new(nr.syntax()));
-                                id
-                            } else {
-                                self.exprs.alloc(Expr::Missing)
-                            },
-                        })
-                        .collect();
-                    let spread = nfl.spread().map(|s| self.collect_expr(s));
-                    Expr::RecordLit { path, fields, spread }
-                } else {
-                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
-                };
-                let res = self.alloc_expr(record_lit, syntax_ptr);
-                for (i, ptr) in field_ptrs.into_iter().enumerate() {
-                    self.source_map.field_map.insert((res, i), ptr);
-                }
-                res
-            }
-            ast::Expr::FieldExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                let name = match e.field_access() {
-                    Some(kind) => kind.as_name(),
-                    _ => Name::missing(),
-                };
-                self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
-            }
-            ast::Expr::AwaitExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                self.alloc_expr(Expr::Await { expr }, syntax_ptr)
-            }
-            ast::Expr::TryExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                self.alloc_expr(Expr::Try { expr }, syntax_ptr)
-            }
-            ast::Expr::CastExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(e.type_ref());
-                self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
-            }
-            ast::Expr::RefExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                let mutability = Mutability::from_mutable(e.is_mut());
-                self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
-            }
-            ast::Expr::PrefixExpr(e) => {
-                let expr = self.collect_expr_opt(e.expr());
-                if let Some(op) = e.op_kind() {
-                    self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
-                } else {
-                    self.alloc_expr(Expr::Missing, syntax_ptr)
-                }
-            }
-            ast::Expr::LambdaExpr(e) => {
-                let mut args = Vec::new();
-                let mut arg_types = Vec::new();
-                if let Some(pl) = e.param_list() {
-                    for param in pl.params() {
-                        let pat = self.collect_pat_opt(param.pat());
-                        let type_ref = param.ascribed_type().map(TypeRef::from_ast);
-                        args.push(pat);
-                        arg_types.push(type_ref);
-                    }
-                }
-                let body = self.collect_expr_opt(e.body());
-                self.alloc_expr(Expr::Lambda { args, arg_types, body }, syntax_ptr)
-            }
-            ast::Expr::BinExpr(e) => {
-                let lhs = self.collect_expr_opt(e.lhs());
-                let rhs = self.collect_expr_opt(e.rhs());
-                let op = e.op_kind().map(BinaryOp::from);
-                self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
-            }
-            ast::Expr::TupleExpr(e) => {
-                let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
-                self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
-            }
-            ast::Expr::ArrayExpr(e) => {
-                let kind = e.kind();
-                match kind {
-                    ArrayExprKind::ElementList(e) => {
-                        let exprs = e.map(|expr| self.collect_expr(expr)).collect();
-                        self.alloc_expr(Expr::Array(Array::ElementList(exprs)), syntax_ptr)
-                    }
-                    ArrayExprKind::Repeat { initializer, repeat } => {
-                        let initializer = self.collect_expr_opt(initializer);
-                        let repeat = self.collect_expr_opt(repeat);
-                        self.alloc_expr(
-                            Expr::Array(Array::Repeat { initializer, repeat }),
-                            syntax_ptr,
-                        )
-                    }
-                }
-            }
-            ast::Expr::Literal(e) => {
-                let lit = match e.kind() {
-                    LiteralKind::IntNumber { suffix } => {
-                        let known_name = suffix
-                            .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known));
-                        Literal::Int(
-                            Default::default(),
-                            known_name.unwrap_or(UncertainIntTy::Unknown),
-                        )
-                    }
-                    LiteralKind::FloatNumber { suffix } => {
-                        let known_name = suffix
-                            .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known));
-                        Literal::Float(
-                            Default::default(),
-                            known_name.unwrap_or(UncertainFloatTy::Unknown),
-                        )
-                    }
-                    LiteralKind::ByteString => Literal::ByteString(Default::default()),
-                    LiteralKind::String => Literal::String(Default::default()),
-                    LiteralKind::Byte => {
-                        Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8()))
-                    }
-                    LiteralKind::Bool => Literal::Bool(Default::default()),
-                    LiteralKind::Char => Literal::Char(Default::default()),
-                };
-                self.alloc_expr(Expr::Literal(lit), syntax_ptr)
-            }
-            ast::Expr::IndexExpr(e) => {
-                let base = self.collect_expr_opt(e.base());
-                let index = self.collect_expr_opt(e.index());
-                self.alloc_expr(Expr::Index { base, index }, syntax_ptr)
-            }
-            // FIXME implement HIR for these:
-            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::MacroCall(e) => {
-                let ast_id = self
-                    .db
-                    .ast_id_map(self.current_file_id)
-                    .ast_id(&e)
-                    .with_file_id(self.current_file_id);
-                if let Some(path) = e.path().and_then(Path::from_ast) {
-                    if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) {
-                        let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db);
-                        let file_id = call_id.as_file(MacroFileKind::Expr);
-                        if let Some(node) = self.db.parse_or_expand(file_id) {
-                            if let Some(expr) = ast::Expr::cast(node) {
-                                log::debug!("macro expansion {:#?}", expr.syntax());
-                                let old_file_id =
-                                    std::mem::replace(&mut self.current_file_id, file_id);
-                                let id = self.collect_expr(expr);
-                                self.current_file_id = old_file_id;
-                                return id;
-                            }
-                        }
-                    }
-                }
-                // FIXME: Instead of just dropping the error from expansion
-                // report it
-                self.alloc_expr(Expr::Missing, syntax_ptr)
-            }
-        }
-    }
-    fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
-        if let Some(expr) = expr {
-            self.collect_expr(expr)
-        } else {
-            self.exprs.alloc(Expr::Missing)
-        }
-    }
-    fn collect_block(&mut self, block: ast::Block) -> ExprId {
-        let statements = block
-            .statements()
-            .map(|s| match s {
-                ast::Stmt::LetStmt(stmt) => {
-                    let pat = self.collect_pat_opt(stmt.pat());
-                    let type_ref = stmt.ascribed_type().map(TypeRef::from_ast);
-                    let initializer = stmt.initializer().map(|e| self.collect_expr(e));
-                    Statement::Let { pat, type_ref, initializer }
-                }
-                ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())),
-            })
-            .collect();
-        let tail = block.expr().map(|e| self.collect_expr(e));
-        self.alloc_expr(Expr::Block { statements, tail }, SyntaxNodePtr::new(block.syntax()))
-    }
-    fn collect_block_opt(&mut self, block: Option<ast::Block>) -> ExprId {
-        if let Some(block) = block {
-            self.collect_block(block)
-        } else {
-            self.exprs.alloc(Expr::Missing)
-        }
-    }
-    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
-        let pattern = match &pat {
-            ast::Pat::BindPat(bp) => {
-                let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let annotation = BindingAnnotation::new(bp.is_mutable(), bp.is_ref());
-                let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
-                Pat::Bind { name, mode: annotation, subpat }
-            }
-            ast::Pat::TupleStructPat(p) => {
-                let path = p.path().and_then(Path::from_ast);
-                let args = p.args().map(|p| self.collect_pat(p)).collect();
-                Pat::TupleStruct { path, args }
-            }
-            ast::Pat::RefPat(p) => {
-                let pat = self.collect_pat_opt(p.pat());
-                let mutability = Mutability::from_mutable(p.is_mut());
-                Pat::Ref { pat, mutability }
-            }
-            ast::Pat::PathPat(p) => {
-                let path = p.path().and_then(Path::from_ast);
-                path.map(Pat::Path).unwrap_or(Pat::Missing)
-            }
-            ast::Pat::TuplePat(p) => {
-                let args = p.args().map(|p| self.collect_pat(p)).collect();
-                Pat::Tuple(args)
-            }
-            ast::Pat::PlaceholderPat(_) => Pat::Wild,
-            ast::Pat::RecordPat(p) => {
-                let path = p.path().and_then(Path::from_ast);
-                let record_field_pat_list =
-                    p.record_field_pat_list().expect("every struct should have a field list");
-                let mut fields: Vec<_> = record_field_pat_list
-                    .bind_pats()
-                    .filter_map(|bind_pat| {
-                        let ast_pat =
-                            ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat");
-                        let pat = self.collect_pat(ast_pat);
-                        let name = bind_pat.name()?.as_name();
-                        Some(RecordFieldPat { name, pat })
-                    })
-                    .collect();
-                let iter = record_field_pat_list.record_field_pats().filter_map(|f| {
-                    let ast_pat = f.pat()?;
-                    let pat = self.collect_pat(ast_pat);
-                    let name = f.name()?.as_name();
-                    Some(RecordFieldPat { name, pat })
-                });
-                fields.extend(iter);
-                Pat::Struct { path, args: fields }
-            }
-            // FIXME: implement
-            ast::Pat::BoxPat(_) => Pat::Missing,
-            ast::Pat::LiteralPat(_) => Pat::Missing,
-            ast::Pat::SlicePat(_) | ast::Pat::RangePat(_) => Pat::Missing,
-        };
-        let ptr = AstPtr::new(&pat);
-        self.alloc_pat(pattern, Either::A(ptr))
-    }
-    fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
-        if let Some(pat) = pat {
-            self.collect_pat(pat)
-        } else {
-            self.pats.alloc(Pat::Missing)
-        }
-    }
-    fn collect_const_body(&mut self, node: ast::ConstDef) {
-        let body = self.collect_expr_opt(node.body());
-        self.body_expr = Some(body);
-    }
-    fn collect_static_body(&mut self, node: ast::StaticDef) {
-        let body = self.collect_expr_opt(node.body());
-        self.body_expr = Some(body);
-    }
-    fn collect_fn_body(&mut self, node: ast::FnDef) {
-        if let Some(param_list) = node.param_list() {
-            if let Some(self_param) = param_list.self_param() {
-                let ptr = AstPtr::new(&self_param);
-                let param_pat = self.alloc_pat(
-                    Pat::Bind {
-                        name: SELF_PARAM,
-                        mode: BindingAnnotation::Unannotated,
-                        subpat: None,
-                    },
-                    Either::B(ptr),
-                );
-                self.params.push(param_pat);
-            }
-            for param in param_list.params() {
-                let pat = if let Some(pat) = param.pat() {
-                    pat
-                } else {
-                    continue;
-                };
-                let param_pat = self.collect_pat(pat);
-                self.params.push(param_pat);
-            }
-        };
-        let body = self.collect_block_opt(node.body());
-        self.body_expr = Some(body);
-    }
-    fn finish(self) -> (Body, BodySourceMap) {
-        let body = Body {
-            owner: self.owner,
-            exprs: self.exprs,
-            pats: self.pats,
-            params: self.params,
-            body_expr: self.body_expr.expect("A body should have been collected"),
-        };
-        (body, self.source_map)
-    }
-}
-impl From<ast::BinOp> for BinaryOp {
-    fn from(ast_op: ast::BinOp) -> Self {
-        match ast_op {
-            ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or),
-            ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And),
-            ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
-            ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }),
-            ast::BinOp::LesserEqualTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false })
-            }
-            ast::BinOp::GreaterEqualTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false })
-            }
-            ast::BinOp::LesserTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true })
-            }
-            ast::BinOp::GreaterTest => {
-                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true })
-            }
-            ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add),
-            ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul),
-            ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub),
-            ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div),
-            ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem),
-            ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl),
-            ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr),
-            ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor),
-            ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr),
-            ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd),
-            ast::BinOp::Assignment => BinaryOp::Assignment { op: None },
-            ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) },
-            ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) },
-            ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) },
-            ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) },
-            ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) },
-            ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) },
-            ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) },
-            ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) },
-            ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) },
-            ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) },
-        }
-    }
-}
 pub(crate) fn body_with_source_map_query(
    db: &impl HirDatabase,
    def: DefWithBody,
 ) -> (Arc<Body>, Arc<BodySourceMap>) {
-    let mut collector;
+    let mut params = None;
-    match def {
+    let (file_id, body) = match def {
-        DefWithBody::Const(ref c) => {
+        DefWithBody::Function(f) => {
-            let src = c.source(db);
-            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
-            collector.collect_const_body(src.ast)
-        }
-        DefWithBody::Function(ref f) => {
            let src = f.source(db);
-            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
+            params = src.ast.param_list();
-            collector.collect_fn_body(src.ast)
+            (src.file_id, src.ast.body().map(ast::Expr::from))
+        }
+        DefWithBody::Const(c) => {
+            let src = c.source(db);
+            (src.file_id, src.ast.body())
        }
-        DefWithBody::Static(ref s) => {
+        DefWithBody::Static(s) => {
            let src = s.source(db);
-            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
+            (src.file_id, src.ast.body())
-            collector.collect_static_body(src.ast)
        }
-    }
+    };
-    let (body, source_map) = collector.finish();
+    let (body, source_map) = lower::lower(db, def.resolver(db), file_id, def, params, body);
    (Arc::new(body), Arc::new(source_map))
 }
diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir/src/expr/lower.rs
new file mode 100644
index 000000000..6afd80989
--- /dev/null
+++ b/crates/ra_hir/src/expr/lower.rs
@@ -0,0 +1,630 @@
+use ra_arena::Arena;
+use ra_syntax::{
+    ast::{
+        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
+        TypeAscriptionOwner,
+    },
+    AstNode, AstPtr,
+};
+use test_utils::tested_by;
+use crate::{
+    name::{AsName, Name, SELF_PARAM},
+    path::GenericArgs,
+    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
+    type_ref::TypeRef,
+    DefWithBody, Either, HirDatabase, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path,
+    Resolver, Source,
+};
+use super::{
+    ArithOp, Array, BinaryOp, BindingAnnotation, Body, BodySourceMap, CmpOp, Expr, ExprId, Literal,
+    LogicOp, MatchArm, Ordering, Pat, PatId, PatPtr, RecordFieldPat, RecordLitField, Statement,
+};
+pub(super) fn lower(
+    db: &impl HirDatabase,
+    resolver: Resolver,
+    file_id: HirFileId,
+    owner: DefWithBody,
+    params: Option<ast::ParamList>,
+    body: Option<ast::Expr>,
+) -> (Body, BodySourceMap) {
+    ExprCollector {
+        resolver,
+        db,
+        original_file_id: file_id,
+        current_file_id: file_id,
+        source_map: BodySourceMap::default(),
+        body: Body {
+            owner,
+            exprs: Arena::default(),
+            pats: Arena::default(),
+            params: Vec::new(),
+            body_expr: ExprId((!0).into()),
+        },
+    }
+    .collect(params, body)
+}
+struct ExprCollector<DB> {
+    db: DB,
+    resolver: Resolver,
+    // Expr collector expands macros along the way. original points to the file
+    // we started with, current points to the current macro expansion. source
+    // maps don't support macros yet, so we only record info into source map if
+    // current == original (see #1196)
+    original_file_id: HirFileId,
+    current_file_id: HirFileId,
+    body: Body,
+    source_map: BodySourceMap,
+}
+impl<'a, DB> ExprCollector<&'a DB>
+where
+    DB: HirDatabase,
+{
+    fn collect(
+        mut self,
+        param_list: Option<ast::ParamList>,
+        body: Option<ast::Expr>,
+    ) -> (Body, BodySourceMap) {
+        if let Some(param_list) = param_list {
+            if let Some(self_param) = param_list.self_param() {
+                let ptr = AstPtr::new(&self_param);
+                let param_pat = self.alloc_pat(
+                    Pat::Bind {
+                        name: SELF_PARAM,
+                        mode: BindingAnnotation::Unannotated,
+                        subpat: None,
+                    },
+                    Either::B(ptr),
+                );
+                self.body.params.push(param_pat);
+            }
+            for param in param_list.params() {
+                let pat = match param.pat() {
+                    None => continue,
+                    Some(pat) => pat,
+                };
+                let param_pat = self.collect_pat(pat);
+                self.body.params.push(param_pat);
+            }
+        };
+        self.body.body_expr = self.collect_expr_opt(body);
+        (self.body, self.source_map)
+    }
+    fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
+        let ptr = Either::A(ptr);
+        let id = self.body.exprs.alloc(expr);
+        if self.current_file_id == self.original_file_id {
+            self.source_map.expr_map.insert(ptr, id);
+        }
+        self.source_map
+            .expr_map_back
+            .insert(id, Source { file_id: self.current_file_id, ast: ptr });
+        id
+    }
+    // desugared exprs don't have ptr, that's wrong and should be fixed
+    // somehow.
+    fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
+        self.body.exprs.alloc(expr)
+    }
+    fn alloc_expr_field_shorthand(&mut self, expr: Expr, ptr: AstPtr<ast::RecordField>) -> ExprId {
+        let ptr = Either::B(ptr);
+        let id = self.body.exprs.alloc(expr);
+        if self.current_file_id == self.original_file_id {
+            self.source_map.expr_map.insert(ptr, id);
+        }
+        self.source_map
+            .expr_map_back
+            .insert(id, Source { file_id: self.current_file_id, ast: ptr });
+        id
+    }
+    fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
+        let id = self.body.pats.alloc(pat);
+        if self.current_file_id == self.original_file_id {
+            self.source_map.pat_map.insert(ptr, id);
+        }
+        self.source_map.pat_map_back.insert(id, Source { file_id: self.current_file_id, ast: ptr });
+        id
+    }
+    fn empty_block(&mut self) -> ExprId {
+        let block = Expr::Block { statements: Vec::new(), tail: None };
+        self.body.exprs.alloc(block)
+    }
+    fn missing_expr(&mut self) -> ExprId {
+        self.body.exprs.alloc(Expr::Missing)
+    }
+    fn missing_pat(&mut self) -> PatId {
+        self.body.pats.alloc(Pat::Missing)
+    }
+    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
+        let syntax_ptr = AstPtr::new(&expr);
+        match expr {
+            ast::Expr::IfExpr(e) => {
+                let then_branch = self.collect_block_opt(e.then_branch());
+                let else_branch = e.else_branch().map(|b| match b {
+                    ast::ElseBranch::Block(it) => self.collect_block(it),
+                    ast::ElseBranch::IfExpr(elif) => {
+                        let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
+                        self.collect_expr(expr)
+                    }
+                });
+                let condition = match e.condition() {
+                    None => self.missing_expr(),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.missing_pat();
+                            let arms = vec![
+                                MatchArm { pats: vec![pat], expr: then_branch, guard: None },
+                                MatchArm {
+                                    pats: vec![placeholder_pat],
+                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
+                                    guard: None,
+                                },
+                            ];
+                            return self
+                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
+                        }
+                    },
+                };
+                self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
+            }
+            ast::Expr::TryBlockExpr(e) => {
+                let body = self.collect_block_opt(e.body());
+                self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
+            }
+            ast::Expr::BlockExpr(e) => self.collect_block(e),
+            ast::Expr::LoopExpr(e) => {
+                let body = self.collect_block_opt(e.loop_body());
+                self.alloc_expr(Expr::Loop { body }, syntax_ptr)
+            }
+            ast::Expr::WhileExpr(e) => {
+                let body = self.collect_block_opt(e.loop_body());
+                let condition = match e.condition() {
+                    None => self.missing_expr(),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            tested_by!(infer_while_let);
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.missing_pat();
+                            let break_ = self.alloc_expr_desugared(Expr::Break { expr: None });
+                            let arms = vec![
+                                MatchArm { pats: vec![pat], expr: body, guard: None },
+                                MatchArm { pats: vec![placeholder_pat], expr: break_, guard: None },
+                            ];
+                            let match_expr =
+                                self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
+                            return self.alloc_expr(Expr::Loop { body: match_expr }, syntax_ptr);
+                        }
+                    },
+                };
+                self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
+            }
+            ast::Expr::ForExpr(e) => {
+                let iterable = self.collect_expr_opt(e.iterable());
+                let pat = self.collect_pat_opt(e.pat());
+                let body = self.collect_block_opt(e.loop_body());
+                self.alloc_expr(Expr::For { iterable, pat, body }, syntax_ptr)
+            }
+            ast::Expr::CallExpr(e) => {
+                let callee = self.collect_expr_opt(e.expr());
+                let args = if let Some(arg_list) = e.arg_list() {
+                    arg_list.args().map(|e| self.collect_expr(e)).collect()
+                } else {
+                    Vec::new()
+                };
+                self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
+            }
+            ast::Expr::MethodCallExpr(e) => {
+                let receiver = self.collect_expr_opt(e.expr());
+                let args = if let Some(arg_list) = e.arg_list() {
+                    arg_list.args().map(|e| self.collect_expr(e)).collect()
+                } else {
+                    Vec::new()
+                };
+                let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
+                let generic_args = e.type_arg_list().and_then(GenericArgs::from_ast);
+                self.alloc_expr(
+                    Expr::MethodCall { receiver, method_name, args, generic_args },
+                    syntax_ptr,
+                )
+            }
+            ast::Expr::MatchExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let arms = if let Some(match_arm_list) = e.match_arm_list() {
+                    match_arm_list
+                        .arms()
+                        .map(|arm| MatchArm {
+                            pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
+                            expr: self.collect_expr_opt(arm.expr()),
+                            guard: arm
+                                .guard()
+                                .and_then(|guard| guard.expr())
+                                .map(|e| self.collect_expr(e)),
+                        })
+                        .collect()
+                } else {
+                    Vec::new()
+                };
+                self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
+            }
+            ast::Expr::PathExpr(e) => {
+                let path =
+                    e.path().and_then(Path::from_ast).map(Expr::Path).unwrap_or(Expr::Missing);
+                self.alloc_expr(path, syntax_ptr)
+            }
+            ast::Expr::ContinueExpr(_e) => {
+                // FIXME: labels
+                self.alloc_expr(Expr::Continue, syntax_ptr)
+            }
+            ast::Expr::BreakExpr(e) => {
+                let expr = e.expr().map(|e| self.collect_expr(e));
+                self.alloc_expr(Expr::Break { expr }, syntax_ptr)
+            }
+            ast::Expr::ParenExpr(e) => {
+                let inner = self.collect_expr_opt(e.expr());
+                // make the paren expr point to the inner expression as well
+                self.source_map.expr_map.insert(Either::A(syntax_ptr), inner);
+                inner
+            }
+            ast::Expr::ReturnExpr(e) => {
+                let expr = e.expr().map(|e| self.collect_expr(e));
+                self.alloc_expr(Expr::Return { expr }, syntax_ptr)
+            }
+            ast::Expr::RecordLit(e) => {
+                let path = e.path().and_then(Path::from_ast);
+                let mut field_ptrs = Vec::new();
+                let record_lit = if let Some(nfl) = e.record_field_list() {
+                    let fields = nfl
+                        .fields()
+                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
+                        .map(|field| RecordLitField {
+                            name: field
+                                .name_ref()
+                                .map(|nr| nr.as_name())
+                                .unwrap_or_else(Name::missing),
+                            expr: if let Some(e) = field.expr() {
+                                self.collect_expr(e)
+                            } else if let Some(nr) = field.name_ref() {
+                                // field shorthand
+                                self.alloc_expr_field_shorthand(
+                                    Expr::Path(Path::from_name_ref(&nr)),
+                                    AstPtr::new(&field),
+                                )
+                            } else {
+                                self.missing_expr()
+                            },
+                        })
+                        .collect();
+                    let spread = nfl.spread().map(|s| self.collect_expr(s));
+                    Expr::RecordLit { path, fields, spread }
+                } else {
+                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
+                };
+                let res = self.alloc_expr(record_lit, syntax_ptr);
+                for (i, ptr) in field_ptrs.into_iter().enumerate() {
+                    self.source_map.field_map.insert((res, i), ptr);
+                }
+                res
+            }
+            ast::Expr::FieldExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let name = match e.field_access() {
+                    Some(kind) => kind.as_name(),
+                    _ => Name::missing(),
+                };
+                self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
+            }
+            ast::Expr::AwaitExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                self.alloc_expr(Expr::Await { expr }, syntax_ptr)
+            }
+            ast::Expr::TryExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                self.alloc_expr(Expr::Try { expr }, syntax_ptr)
+            }
+            ast::Expr::CastExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let type_ref = TypeRef::from_ast_opt(e.type_ref());
+                self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
+            }
+            ast::Expr::RefExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let mutability = Mutability::from_mutable(e.is_mut());
+                self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
+            }
+            ast::Expr::PrefixExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                if let Some(op) = e.op_kind() {
+                    self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
+                } else {
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                }
+            }
+            ast::Expr::LambdaExpr(e) => {
+                let mut args = Vec::new();
+                let mut arg_types = Vec::new();
+                if let Some(pl) = e.param_list() {
+                    for param in pl.params() {
+                        let pat = self.collect_pat_opt(param.pat());
+                        let type_ref = param.ascribed_type().map(TypeRef::from_ast);
+                        args.push(pat);
+                        arg_types.push(type_ref);
+                    }
+                }
+                let body = self.collect_expr_opt(e.body());
+                self.alloc_expr(Expr::Lambda { args, arg_types, body }, syntax_ptr)
+            }
+            ast::Expr::BinExpr(e) => {
+                let lhs = self.collect_expr_opt(e.lhs());
+                let rhs = self.collect_expr_opt(e.rhs());
+                let op = e.op_kind().map(BinaryOp::from);
+                self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
+            }
+            ast::Expr::TupleExpr(e) => {
+                let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
+                self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
+            }
+            ast::Expr::ArrayExpr(e) => {
+                let kind = e.kind();
+                match kind {
+                    ArrayExprKind::ElementList(e) => {
+                        let exprs = e.map(|expr| self.collect_expr(expr)).collect();
+                        self.alloc_expr(Expr::Array(Array::ElementList(exprs)), syntax_ptr)
+                    }
+                    ArrayExprKind::Repeat { initializer, repeat } => {
+                        let initializer = self.collect_expr_opt(initializer);
+                        let repeat = self.collect_expr_opt(repeat);
+                        self.alloc_expr(
+                            Expr::Array(Array::Repeat { initializer, repeat }),
+                            syntax_ptr,
+                        )
+                    }
+                }
+            }
+            ast::Expr::Literal(e) => {
+                let lit = match e.kind() {
+                    LiteralKind::IntNumber { suffix } => {
+                        let known_name = suffix
+                            .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known));
+                        Literal::Int(
+                            Default::default(),
+                            known_name.unwrap_or(UncertainIntTy::Unknown),
+                        )
+                    }
+                    LiteralKind::FloatNumber { suffix } => {
+                        let known_name = suffix
+                            .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known));
+                        Literal::Float(
+                            Default::default(),
+                            known_name.unwrap_or(UncertainFloatTy::Unknown),
+                        )
+                    }
+                    LiteralKind::ByteString => Literal::ByteString(Default::default()),
+                    LiteralKind::String => Literal::String(Default::default()),
+                    LiteralKind::Byte => {
+                        Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8()))
+                    }
+                    LiteralKind::Bool => Literal::Bool(Default::default()),
+                    LiteralKind::Char => Literal::Char(Default::default()),
+                };
+                self.alloc_expr(Expr::Literal(lit), syntax_ptr)
+            }
+            ast::Expr::IndexExpr(e) => {
+                let base = self.collect_expr_opt(e.base());
+                let index = self.collect_expr_opt(e.index());
+                self.alloc_expr(Expr::Index { base, index }, syntax_ptr)
+            }
+            // FIXME implement HIR for these:
+            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::Expr::MacroCall(e) => {
+                let ast_id = self
+                    .db
+                    .ast_id_map(self.current_file_id)
+                    .ast_id(&e)
+                    .with_file_id(self.current_file_id);
+                if let Some(path) = e.path().and_then(Path::from_ast) {
+                    if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) {
+                        let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db);
+                        let file_id = call_id.as_file(MacroFileKind::Expr);
+                        if let Some(node) = self.db.parse_or_expand(file_id) {
+                            if let Some(expr) = ast::Expr::cast(node) {
+                                log::debug!("macro expansion {:#?}", expr.syntax());
+                                let old_file_id =
+                                    std::mem::replace(&mut self.current_file_id, file_id);
+                                let id = self.collect_expr(expr);
+                                self.current_file_id = old_file_id;
+                                return id;
+                            }
+                        }
+                    }
+                }
+                // FIXME: Instead of just dropping the error from expansion
+                // report it
+                self.alloc_expr(Expr::Missing, syntax_ptr)
+            }
+        }
+    }
+    fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
+        if let Some(expr) = expr {
+            self.collect_expr(expr)
+        } else {
+            self.missing_expr()
+        }
+    }
+    fn collect_block(&mut self, expr: ast::BlockExpr) -> ExprId {
+        let syntax_node_ptr = AstPtr::new(&expr.clone().into());
+        let block = match expr.block() {
+            Some(block) => block,
+            None => return self.alloc_expr(Expr::Missing, syntax_node_ptr),
+        };
+        let statements = block
+            .statements()
+            .map(|s| match s {
+                ast::Stmt::LetStmt(stmt) => {
+                    let pat = self.collect_pat_opt(stmt.pat());
+                    let type_ref = stmt.ascribed_type().map(TypeRef::from_ast);
+                    let initializer = stmt.initializer().map(|e| self.collect_expr(e));
+                    Statement::Let { pat, type_ref, initializer }
+                }
+                ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())),
+            })
+            .collect();
+        let tail = block.expr().map(|e| self.collect_expr(e));
+        self.alloc_expr(Expr::Block { statements, tail }, syntax_node_ptr)
+    }
+    fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId {
+        if let Some(block) = expr {
+            self.collect_block(block)
+        } else {
+            self.missing_expr()
+        }
+    }
+    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
+        let pattern = match &pat {
+            ast::Pat::BindPat(bp) => {
+                let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
+                let annotation = BindingAnnotation::new(bp.is_mutable(), bp.is_ref());
+                let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
+                Pat::Bind { name, mode: annotation, subpat }
+            }
+            ast::Pat::TupleStructPat(p) => {
+                let path = p.path().and_then(Path::from_ast);
+                let args = p.args().map(|p| self.collect_pat(p)).collect();
+                Pat::TupleStruct { path, args }
+            }
+            ast::Pat::RefPat(p) => {
+                let pat = self.collect_pat_opt(p.pat());
+                let mutability = Mutability::from_mutable(p.is_mut());
+                Pat::Ref { pat, mutability }
+            }
+            ast::Pat::PathPat(p) => {
+                let path = p.path().and_then(Path::from_ast);
+                path.map(Pat::Path).unwrap_or(Pat::Missing)
+            }
+            ast::Pat::TuplePat(p) => {
+                let args = p.args().map(|p| self.collect_pat(p)).collect();
+                Pat::Tuple(args)
+            }
+            ast::Pat::PlaceholderPat(_) => Pat::Wild,
+            ast::Pat::RecordPat(p) => {
+                let path = p.path().and_then(Path::from_ast);
+                let record_field_pat_list =
+                    p.record_field_pat_list().expect("every struct should have a field list");
+                let mut fields: Vec<_> = record_field_pat_list
+                    .bind_pats()
+                    .filter_map(|bind_pat| {
+                        let ast_pat =
+                            ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat");
+                        let pat = self.collect_pat(ast_pat);
+                        let name = bind_pat.name()?.as_name();
+                        Some(RecordFieldPat { name, pat })
+                    })
+                    .collect();
+                let iter = record_field_pat_list.record_field_pats().filter_map(|f| {
+                    let ast_pat = f.pat()?;
+                    let pat = self.collect_pat(ast_pat);
+                    let name = f.name()?.as_name();
+                    Some(RecordFieldPat { name, pat })
+                });
+                fields.extend(iter);
+                Pat::Record { path, args: fields }
+            }
+            // FIXME: implement
+            ast::Pat::BoxPat(_) => Pat::Missing,
+            ast::Pat::LiteralPat(_) => Pat::Missing,
+            ast::Pat::SlicePat(_) | ast::Pat::RangePat(_) => Pat::Missing,
+        };
+        let ptr = AstPtr::new(&pat);
+        self.alloc_pat(pattern, Either::A(ptr))
+    }
+    fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
+        if let Some(pat) = pat {
+            self.collect_pat(pat)
+        } else {
+            self.missing_pat()
+        }
+    }
+}
+impl From<ast::BinOp> for BinaryOp {
+    fn from(ast_op: ast::BinOp) -> Self {
+        match ast_op {
+            ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or),
+            ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And),
+            ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
+            ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }),
+            ast::BinOp::LesserEqualTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false })
+            }
+            ast::BinOp::GreaterEqualTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false })
+            }
+            ast::BinOp::LesserTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true })
+            }
+            ast::BinOp::GreaterTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true })
+            }
+            ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add),
+            ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul),
+            ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub),
+            ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div),
+            ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem),
+            ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl),
+            ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr),
+            ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor),
+            ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr),
+            ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd),
+            ast::BinOp::Assignment => BinaryOp::Assignment { op: None },
+            ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) },
+            ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) },
+            ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) },
+            ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) },
+            ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) },
+            ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) },
+            ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) },
+            ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) },
+            ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) },
+            ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) },
+        }
+    }
+}
diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs
index 79e1857f9..b6d7f3fc1 100644
--- a/crates/ra_hir/src/expr/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -172,7 +172,7 @@ fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope
 #[cfg(test)]
 mod tests {
    use ra_db::SourceDatabase;
-    use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNodePtr};
+    use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
    use test_utils::{assert_eq_text, extract_offset};
    use crate::{mock::MockDatabase, source_binder::SourceAnalyzer};
@@ -194,8 +194,7 @@ mod tests {
        let analyzer = SourceAnalyzer::new(&db, file_id, marker.syntax(), None);
        let scopes = analyzer.scopes();
-        let expr_id =
+        let expr_id = analyzer.body_source_map().node_expr(&marker.into()).unwrap();
-            analyzer.body_source_map().syntax_expr(SyntaxNodePtr::new(marker.syntax())).unwrap();
        let scope = scopes.scope_for(expr_id);
        let actual = scopes
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index c8ae19869..1202913e2 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -1,9 +1,8 @@
-use rustc_hash::FxHashSet;
 use std::sync::Arc;
-use ra_syntax::ast::{AstNode, RecordLit};
+use ra_syntax::ast;
+use rustc_hash::FxHashSet;
-use super::{Expr, ExprId, RecordLitField};
 use crate::{
    adt::AdtDef,
    diagnostics::{DiagnosticSink, MissingFields, MissingOkInTailExpr},
@@ -11,9 +10,10 @@ use crate::{
    name,
    path::{PathKind, PathSegment},
    ty::{ApplicationTy, InferenceResult, Ty, TypeCtor},
-    Function, HasSource, HirDatabase, ModuleDef, Name, Path, PerNs, Resolution,
+    Function, HirDatabase, ModuleDef, Name, Path, PerNs, Resolution,
 };
-use ra_syntax::ast;
+use super::{Expr, ExprId, RecordLitField};
 pub(crate) struct ExprValidator<'a, 'b: 'a> {
    func: Function,
@@ -79,21 +79,20 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            return;
        }
        let source_map = self.func.body_source_map(db);
-        let file_id = self.func.source(db).file_id;
-        let parse = db.parse(file_id.original_file(db));
+        if let Some(source_ptr) = source_map.expr_syntax(id) {
-        let source_file = parse.tree();
+            if let Some(expr) = source_ptr.ast.a() {
-        if let Some(field_list_node) = source_map
+                let root = source_ptr.file_syntax(db);
-            .expr_syntax(id)
+                if let ast::Expr::RecordLit(record_lit) = expr.to_node(&root) {
-            .map(|ptr| ptr.to_node(source_file.syntax()))
+                    if let Some(field_list) = record_lit.record_field_list() {
-            .and_then(RecordLit::cast)
+                        self.sink.push(MissingFields {
-            .and_then(|lit| lit.record_field_list())
+                            file: source_ptr.file_id,
-        {
+                            field_list: AstPtr::new(&field_list),
-            let field_list_ptr = AstPtr::new(&field_list_node);
+                            missed_fields,
-            self.sink.push(MissingFields {
+                        })
-                file: file_id,
+                    }
-                field_list: field_list_ptr,
+                }
-                missed_fields,
+            }
-            })
        }
    }
@@ -133,10 +132,11 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        if params.len() == 2 && &params[0] == &mismatch.actual {
            let source_map = self.func.body_source_map(db);
-            let file_id = self.func.source(db).file_id;
-            if let Some(expr) = source_map.expr_syntax(id).and_then(|n| n.cast::<ast::Expr>()) {
+            if let Some(source_ptr) = source_map.expr_syntax(id) {
-                self.sink.push(MissingOkInTailExpr { file: file_id, expr });
+                if let Some(expr) = source_ptr.ast.a() {
+                    self.sink.push(MissingOkInTailExpr { file: source_ptr.file_id, expr });
+                }
            }
        }
    }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 018fcd096..c3e589921 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -69,14 +69,16 @@ pub use self::{
    resolve::Resolution,
    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
    source_id::{AstIdMap, ErasedFileAstId},
-    ty::{display::HirDisplay, ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor},
+    ty::{
+        display::HirDisplay, ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
+    },
    type_ref::Mutability,
 };
 pub use self::code_model::{
    docs::{DocDef, Docs, Documentation},
-    src::{HasSource, Source},
+    src::{HasBodySource, HasSource, Source},
    BuiltinType, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum,
-    EnumVariant, FieldSource, FnData, Function, MacroDef, Module, ModuleDef, ModuleSource, Static,
+    EnumVariant, FieldSource, FnData, Function, HasBody, MacroDef, Module, ModuleDef, ModuleSource,
-    Struct, StructField, Trait, TypeAlias, Union,
+    Static, Struct, StructField, Trait, TypeAlias, Union,
 };
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 5ee71e421..24316fc91 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -31,7 +31,8 @@ pub struct GenericArgs {
    /// Self type. Otherwise, when we have a path `Trait<X, Y>`, the Self type
    /// is left out.
    pub has_self_type: bool,
-    // someday also bindings
+    /// Associated type bindings like in `Iterator<Item = T>`.
+    pub bindings: Vec<(Name, TypeRef)>,
 }
 /// A single generic argument.
@@ -170,16 +171,24 @@ impl GenericArgs {
            let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
            args.push(GenericArg::Type(type_ref));
        }
-        // lifetimes and assoc type args ignored for now
+        // lifetimes ignored for now
-        if !args.is_empty() {
+        let mut bindings = Vec::new();
-            Some(GenericArgs { args, has_self_type: false })
+        for assoc_type_arg in node.assoc_type_args() {
-        } else {
+            if let Some(name_ref) = assoc_type_arg.name_ref() {
+                let name = name_ref.as_name();
+                let type_ref = TypeRef::from_ast_opt(assoc_type_arg.type_ref());
+                bindings.push((name, type_ref));
+            }
+        }
+        if args.is_empty() && bindings.is_empty() {
            None
+        } else {
+            Some(GenericArgs { args, has_self_type: false, bindings })
        }
    }
    pub(crate) fn empty() -> GenericArgs {
-        GenericArgs { args: Vec::new(), has_self_type: false }
+        GenericArgs { args: Vec::new(), has_self_type: false, bindings: Vec::new() }
    }
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 56ff7da3a..fdbe5e8b0 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -27,9 +27,9 @@ use crate::{
    name,
    path::{PathKind, PathSegment},
    ty::method_resolution::implements_trait,
-    AsName, AstId, Const, Crate, DefWithBody, Either, Enum, Function, HirDatabase, HirFileId,
+    AsName, AstId, Const, Crate, DefWithBody, Either, Enum, Function, HasBody, HirDatabase,
-    MacroDef, Module, ModuleDef, Name, Path, PerNs, Resolution, Resolver, Static, Struct, Trait,
+    HirFileId, MacroDef, Module, ModuleDef, Name, Path, PerNs, Resolution, Resolver, Static,
-    Ty,
+    Struct, Trait, Ty,
 };
 /// Locates the module by `FileId`. Picks topmost module in the file.
@@ -228,7 +228,7 @@ impl SourceAnalyzer {
            let scopes = db.expr_scopes(def);
            let scope = match offset {
                None => scope_for(&scopes, &source_map, &node),
-                Some(offset) => scope_for_offset(&scopes, &source_map, offset),
+                Some(offset) => scope_for_offset(&scopes, &source_map, file_id.into(), offset),
            };
            let resolver = expr::resolver_for_scope(def.body(db), db, scope);
            SourceAnalyzer {
@@ -330,6 +330,7 @@ impl SourceAnalyzer {
                    .body_source_map
                    .as_ref()?
                    .pat_syntax(it)?
+                    .ast // FIXME: ignoring file_id here is definitelly wrong
                    .map_a(|ptr| ptr.cast::<ast::BindPat>().unwrap());
                PathResolution::LocalBinding(pat_ptr)
            }
@@ -354,7 +355,7 @@ impl SourceAnalyzer {
        ret.and_then(|entry| {
            Some(ScopeEntryWithSyntax {
                name: entry.name().clone(),
-                ptr: source_map.pat_syntax(entry.pat())?,
+                ptr: source_map.pat_syntax(entry.pat())?.ast,
            })
        })
    }
@@ -462,25 +463,35 @@ fn scope_for(
    node: &SyntaxNode,
 ) -> Option<ScopeId> {
    node.ancestors()
-        .map(|it| SyntaxNodePtr::new(&it))
+        .filter_map(ast::Expr::cast)
-        .filter_map(|ptr| source_map.syntax_expr(ptr))
+        .filter_map(|it| source_map.node_expr(&it))
        .find_map(|it| scopes.scope_for(it))
 }
 fn scope_for_offset(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
+    file_id: HirFileId,
    offset: TextUnit,
 ) -> Option<ScopeId> {
    scopes
        .scope_by_expr()
        .iter()
-        .filter_map(|(id, scope)| Some((source_map.expr_syntax(*id)?, scope)))
+        .filter_map(|(id, scope)| {
+            let source = source_map.expr_syntax(*id)?;
+            // FIXME: correctly handle macro expansion
+            if source.file_id != file_id {
+                return None;
+            }
+            let syntax_node_ptr =
+                source.ast.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
+            Some((syntax_node_ptr, scope))
+        })
        // find containing scope
        .min_by_key(|(ptr, _scope)| {
            (!(ptr.range().start() <= offset && offset <= ptr.range().end()), ptr.range().len())
        })
-        .map(|(ptr, scope)| adjust(scopes, source_map, ptr, offset).unwrap_or(*scope))
+        .map(|(ptr, scope)| adjust(scopes, source_map, ptr, file_id, offset).unwrap_or(*scope))
 }
 // XXX: during completion, cursor might be outside of any particular
@@ -489,13 +500,23 @@ fn adjust(
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
    ptr: SyntaxNodePtr,
+    file_id: HirFileId,
    offset: TextUnit,
 ) -> Option<ScopeId> {
    let r = ptr.range();
    let child_scopes = scopes
        .scope_by_expr()
        .iter()
-        .filter_map(|(id, scope)| Some((source_map.expr_syntax(*id)?, scope)))
+        .filter_map(|(id, scope)| {
+            let source = source_map.expr_syntax(*id)?;
+            // FIXME: correctly handle macro expansion
+            if source.file_id != file_id {
+                return None;
+            }
+            let syntax_node_ptr =
+                source.ast.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
+            Some((syntax_node_ptr, scope))
+        })
        .map(|(ptr, scope)| (ptr.range(), scope))
        .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index b54c80318..a3df08827 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -120,12 +120,44 @@ pub struct ProjectionTy {
    pub parameters: Substs,
 }
+impl ProjectionTy {
+    pub fn trait_ref(&self, db: &impl HirDatabase) -> TraitRef {
+        TraitRef {
+            trait_: self
+                .associated_ty
+                .parent_trait(db)
+                .expect("projection ty without parent trait"),
+            substs: self.parameters.clone(),
+        }
+    }
+}
+impl TypeWalk for ProjectionTy {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
+        self.parameters.walk(f);
+    }
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        self.parameters.walk_mut(f);
+    }
+}
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct UnselectedProjectionTy {
    pub type_name: Name,
    pub parameters: Substs,
 }
+impl TypeWalk for UnselectedProjectionTy {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
+        self.parameters.walk(f);
+    }
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        self.parameters.walk_mut(f);
+    }
+}
 /// A type.
 ///
 /// See also the `TyKind` enum in rustc (librustc/ty/sty.rs), which represents
@@ -282,20 +314,14 @@ impl TraitRef {
    pub fn self_ty(&self) -> &Ty {
        &self.substs[0]
    }
+}
-    pub fn subst(mut self, substs: &Substs) -> TraitRef {
+impl TypeWalk for TraitRef {
-        self.substs.walk_mut(&mut |ty_mut| {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-            let ty = mem::replace(ty_mut, Ty::Unknown);
-            *ty_mut = ty.subst(substs);
-        });
-        self
-    }
-    pub fn walk(&self, f: &mut impl FnMut(&Ty)) {
        self.substs.walk(f);
    }
-    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
        self.substs.walk_mut(f);
    }
 }
@@ -306,6 +332,8 @@ impl TraitRef {
 pub enum GenericPredicate {
    /// The given trait needs to be implemented for its type parameters.
    Implemented(TraitRef),
+    /// An associated type bindings like in `Iterator<Item = T>`.
+    Projection(ProjectionPredicate),
    /// We couldn't resolve the trait reference. (If some type parameters can't
    /// be resolved, they will just be Unknown).
    Error,
@@ -319,25 +347,35 @@ impl GenericPredicate {
        }
    }
-    pub fn subst(self, substs: &Substs) -> GenericPredicate {
+    pub fn is_implemented(&self) -> bool {
        match self {
-            GenericPredicate::Implemented(trait_ref) => {
+            GenericPredicate::Implemented(_) => true,
-                GenericPredicate::Implemented(trait_ref.subst(substs))
+            _ => false,
-            }
-            GenericPredicate::Error => self,
        }
    }
-    pub fn walk(&self, f: &mut impl FnMut(&Ty)) {
+    pub fn trait_ref(&self, db: &impl HirDatabase) -> Option<TraitRef> {
+        match self {
+            GenericPredicate::Implemented(tr) => Some(tr.clone()),
+            GenericPredicate::Projection(proj) => Some(proj.projection_ty.trait_ref(db)),
+            GenericPredicate::Error => None,
+        }
+    }
+}
+impl TypeWalk for GenericPredicate {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        match self {
            GenericPredicate::Implemented(trait_ref) => trait_ref.walk(f),
+            GenericPredicate::Projection(projection_pred) => projection_pred.walk(f),
            GenericPredicate::Error => {}
        }
    }
-    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
        match self {
            GenericPredicate::Implemented(trait_ref) => trait_ref.walk_mut(f),
+            GenericPredicate::Projection(projection_pred) => projection_pred.walk_mut(f),
            GenericPredicate::Error => {}
        }
    }
@@ -378,16 +416,16 @@ impl FnSig {
    pub fn ret(&self) -> &Ty {
        &self.params_and_return[self.params_and_return.len() - 1]
    }
+}
-    /// Applies the given substitutions to all types in this signature and
+impl TypeWalk for FnSig {
-    /// returns the result.
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-    pub fn subst(&self, substs: &Substs) -> FnSig {
+        for t in self.params_and_return.iter() {
-        let result: Vec<_> =
+            t.walk(f);
-            self.params_and_return.iter().map(|ty| ty.clone().subst(substs)).collect();
+        }
-        FnSig { params_and_return: result.into() }
    }
-    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
        // Without an Arc::make_mut_slice, we can't avoid the clone here:
        let mut v: Vec<_> = self.params_and_return.iter().cloned().collect();
        for t in &mut v {
@@ -411,64 +449,6 @@ impl Ty {
        Ty::apply(TypeCtor::Tuple { cardinality: 0 }, Substs::empty())
    }
-    pub fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        match self {
-            Ty::Apply(a_ty) => {
-                for t in a_ty.parameters.iter() {
-                    t.walk(f);
-                }
-            }
-            Ty::Projection(p_ty) => {
-                for t in p_ty.parameters.iter() {
-                    t.walk(f);
-                }
-            }
-            Ty::UnselectedProjection(p_ty) => {
-                for t in p_ty.parameters.iter() {
-                    t.walk(f);
-                }
-            }
-            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
-                for p in predicates.iter() {
-                    p.walk(f);
-                }
-            }
-            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
-        }
-        f(self);
-    }
-    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
-        match self {
-            Ty::Apply(a_ty) => {
-                a_ty.parameters.walk_mut(f);
-            }
-            Ty::Projection(p_ty) => {
-                p_ty.parameters.walk_mut(f);
-            }
-            Ty::UnselectedProjection(p_ty) => {
-                p_ty.parameters.walk_mut(f);
-            }
-            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
-                let mut v: Vec<_> = predicates.iter().cloned().collect();
-                for p in &mut v {
-                    p.walk_mut(f);
-                }
-                *predicates = v.into();
-            }
-            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
-        }
-        f(self);
-    }
-    fn fold(mut self, f: &mut impl FnMut(Ty) -> Ty) -> Ty {
-        self.walk_mut(&mut |ty_mut| {
-            let ty = mem::replace(ty_mut, Ty::Unknown);
-            *ty_mut = f(ty);
-        });
-        self
-    }
    pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
        match self {
            Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(mutability), parameters }) => {
@@ -544,10 +524,53 @@ impl Ty {
        }
    }
+    /// Returns the type parameters of this type if it has some (i.e. is an ADT
+    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
+    pub fn substs(&self) -> Option<Substs> {
+        match self {
+            Ty::Apply(ApplicationTy { parameters, .. }) => Some(parameters.clone()),
+            _ => None,
+        }
+    }
+    /// If this is an `impl Trait` or `dyn Trait`, returns that trait.
+    pub fn inherent_trait(&self) -> Option<Trait> {
+        match self {
+            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
+                predicates.iter().find_map(|pred| match pred {
+                    GenericPredicate::Implemented(tr) => Some(tr.trait_),
+                    _ => None,
+                })
+            }
+            _ => None,
+        }
+    }
+}
+/// This allows walking structures that contain types to do something with those
+/// types, similar to Chalk's `Fold` trait.
+pub trait TypeWalk {
+    fn walk(&self, f: &mut impl FnMut(&Ty));
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty));
+    fn fold(mut self, f: &mut impl FnMut(Ty) -> Ty) -> Self
+    where
+        Self: Sized,
+    {
+        self.walk_mut(&mut |ty_mut| {
+            let ty = mem::replace(ty_mut, Ty::Unknown);
+            *ty_mut = f(ty);
+        });
+        self
+    }
    /// Replaces type parameters in this type using the given `Substs`. (So e.g.
    /// if `self` is `&[T]`, where type parameter T has index 0, and the
    /// `Substs` contain `u32` at index 0, we'll have `&[u32]` afterwards.)
-    pub fn subst(self, substs: &Substs) -> Ty {
+    fn subst(self, substs: &Substs) -> Self
+    where
+        Self: Sized,
+    {
        self.fold(&mut |ty| match ty {
            Ty::Param { idx, name } => {
                substs.get(idx as usize).cloned().unwrap_or(Ty::Param { idx, name })
@@ -557,24 +580,21 @@ impl Ty {
    }
    /// Substitutes `Ty::Bound` vars (as opposed to type parameters).
-    pub fn subst_bound_vars(self, substs: &Substs) -> Ty {
+    fn subst_bound_vars(self, substs: &Substs) -> Self
+    where
+        Self: Sized,
+    {
        self.fold(&mut |ty| match ty {
            Ty::Bound(idx) => substs.get(idx as usize).cloned().unwrap_or_else(|| Ty::Bound(idx)),
            ty => ty,
        })
    }
-    /// Returns the type parameters of this type if it has some (i.e. is an ADT
-    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
-    pub fn substs(&self) -> Option<Substs> {
-        match self {
-            Ty::Apply(ApplicationTy { parameters, .. }) => Some(parameters.clone()),
-            _ => None,
-        }
-    }
    /// Shifts up `Ty::Bound` vars by `n`.
-    pub fn shift_bound_vars(self, n: i32) -> Ty {
+    fn shift_bound_vars(self, n: i32) -> Self
+    where
+        Self: Sized,
+    {
        self.fold(&mut |ty| match ty {
            Ty::Bound(idx) => {
                assert!(idx as i32 >= -n);
@@ -583,18 +603,57 @@ impl Ty {
            ty => ty,
        })
    }
+}
-    /// If this is an `impl Trait` or `dyn Trait`, returns that trait.
+impl TypeWalk for Ty {
-    pub fn inherent_trait(&self) -> Option<Trait> {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
+        match self {
+            Ty::Apply(a_ty) => {
+                for t in a_ty.parameters.iter() {
+                    t.walk(f);
+                }
+            }
+            Ty::Projection(p_ty) => {
+                for t in p_ty.parameters.iter() {
+                    t.walk(f);
+                }
+            }
+            Ty::UnselectedProjection(p_ty) => {
+                for t in p_ty.parameters.iter() {
+                    t.walk(f);
+                }
+            }
+            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
+                for p in predicates.iter() {
+                    p.walk(f);
+                }
+            }
+            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
+        }
+        f(self);
+    }
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
        match self {
+            Ty::Apply(a_ty) => {
+                a_ty.parameters.walk_mut(f);
+            }
+            Ty::Projection(p_ty) => {
+                p_ty.parameters.walk_mut(f);
+            }
+            Ty::UnselectedProjection(p_ty) => {
+                p_ty.parameters.walk_mut(f);
+            }
            Ty::Dyn(predicates) | Ty::Opaque(predicates) => {
-                predicates.iter().find_map(|pred| match pred {
+                let mut v: Vec<_> = predicates.iter().cloned().collect();
-                    GenericPredicate::Implemented(tr) => Some(tr.trait_),
+                for p in &mut v {
-                    _ => None,
+                    p.walk_mut(f);
-                })
+                }
+                *predicates = v.into();
            }
-            _ => None,
+            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
        }
+        f(self);
    }
 }
@@ -742,20 +801,66 @@ impl HirDisplay for Ty {
                    Ty::Opaque(_) => write!(f, "impl ")?,
                    _ => unreachable!(),
                };
-                // looping by hand here just to format the bounds in a slightly nicer way
+                // Note: This code is written to produce nice results (i.e.
+                // corresponding to surface Rust) for types that can occur in
+                // actual Rust. It will have weird results if the predicates
+                // aren't as expected (i.e. self types = $0, projection
+                // predicates for a certain trait come after the Implemented
+                // predicate for that trait).
                let mut first = true;
+                let mut angle_open = false;
                for p in predicates.iter() {
-                    if !first {
-                        write!(f, " + ")?;
-                    }
-                    first = false;
                    match p {
-                        // don't show the $0 self type
                        GenericPredicate::Implemented(trait_ref) => {
-                            trait_ref.hir_fmt_ext(f, false)?
+                            if angle_open {
+                                write!(f, ">")?;
+                            }
+                            if !first {
+                                write!(f, " + ")?;
+                            }
+                            // We assume that the self type is $0 (i.e. the
+                            // existential) here, which is the only thing that's
+                            // possible in actual Rust, and hence don't print it
+                            write!(
+                                f,
+                                "{}",
+                                trait_ref.trait_.name(f.db).unwrap_or_else(Name::missing)
+                            )?;
+                            if trait_ref.substs.len() > 1 {
+                                write!(f, "<")?;
+                                f.write_joined(&trait_ref.substs[1..], ", ")?;
+                                // there might be assoc type bindings, so we leave the angle brackets open
+                                angle_open = true;
+                            }
+                        }
+                        GenericPredicate::Projection(projection_pred) => {
+                            // in types in actual Rust, these will always come
+                            // after the corresponding Implemented predicate
+                            if angle_open {
+                                write!(f, ", ")?;
+                            } else {
+                                write!(f, "<")?;
+                                angle_open = true;
+                            }
+                            let name = projection_pred.projection_ty.associated_ty.name(f.db);
+                            write!(f, "{} = ", name)?;
+                            projection_pred.ty.hir_fmt(f)?;
+                        }
+                        GenericPredicate::Error => {
+                            if angle_open {
+                                // impl Trait<X, {error}>
+                                write!(f, ", ")?;
+                            } else if !first {
+                                // impl Trait + {error}
+                                write!(f, " + ")?;
+                            }
+                            p.hir_fmt(f)?;
                        }
-                        GenericPredicate::Error => p.hir_fmt(f)?,
                    }
+                    first = false;
+                }
+                if angle_open {
+                    write!(f, ">")?;
                }
            }
            Ty::Unknown => write!(f, "{{unknown}}")?,
@@ -766,13 +871,12 @@ impl HirDisplay for Ty {
 }
 impl TraitRef {
-    fn hir_fmt_ext(
+    fn hir_fmt_ext(&self, f: &mut HirFormatter<impl HirDatabase>, use_as: bool) -> fmt::Result {
-        &self,
+        self.substs[0].hir_fmt(f)?;
-        f: &mut HirFormatter<impl HirDatabase>,
+        if use_as {
-        with_self_ty: bool,
+            write!(f, " as ")?;
-    ) -> fmt::Result {
+        } else {
-        if with_self_ty {
+            write!(f, ": ")?;
-            write!(f, "{}: ", self.substs[0].display(f.db),)?;
        }
        write!(f, "{}", self.trait_.name(f.db).unwrap_or_else(Name::missing))?;
        if self.substs.len() > 1 {
@@ -786,7 +890,7 @@ impl TraitRef {
 impl HirDisplay for TraitRef {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
-        self.hir_fmt_ext(f, true)
+        self.hir_fmt_ext(f, false)
    }
 }
@@ -800,6 +904,16 @@ impl HirDisplay for GenericPredicate {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        match self {
            GenericPredicate::Implemented(trait_ref) => trait_ref.hir_fmt(f)?,
+            GenericPredicate::Projection(projection_pred) => {
+                write!(f, "<")?;
+                projection_pred.projection_ty.trait_ref(f.db).hir_fmt_ext(f, true)?;
+                write!(
+                    f,
+                    ">::{} = {}",
+                    projection_pred.projection_ty.associated_ty.name(f.db),
+                    projection_pred.ty.display(f.db)
+                )?;
+            }
            GenericPredicate::Error => write!(f, "{{error}}")?,
        }
        Ok(())
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index 2535d4ae7..08f52a53b 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -7,7 +7,7 @@ use std::iter::successors;
 use log::{info, warn};
-use super::{traits::Solution, Canonical, Ty};
+use super::{traits::Solution, Canonical, Ty, TypeWalk};
 use crate::{HasGenericParams, HirDatabase, Name, Resolver};
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 812990426..ec3b7ffef 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -30,7 +30,7 @@ use super::{
    autoderef, lower, method_resolution, op, primitive,
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
    ApplicationTy, CallableDef, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef,
-    Ty, TypableDef, TypeCtor,
+    Ty, TypableDef, TypeCtor, TypeWalk,
 };
 use crate::{
    adt::VariantDef,
@@ -50,8 +50,8 @@ use crate::{
    },
    ty::infer::diagnostics::InferenceDiagnostic,
    type_ref::{Mutability, TypeRef},
-    AdtDef, ConstData, DefWithBody, FnData, Function, HirDatabase, ImplItem, ModuleDef, Name, Path,
+    AdtDef, ConstData, DefWithBody, FnData, Function, HasBody, HirDatabase, ImplItem, ModuleDef,
-    StructField,
+    Name, Path, StructField,
 };
 mod unify;
@@ -749,7 +749,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let is_non_ref_pat = match &body[pat] {
            Pat::Tuple(..)
            | Pat::TupleStruct { .. }
-            | Pat::Struct { .. }
+            | Pat::Record { .. }
            | Pat::Range { .. }
            | Pat::Slice { .. } => true,
            // FIXME: Path/Lit might actually evaluate to ref, but inference is unimplemented.
@@ -806,10 +806,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let subty = self.infer_pat(*pat, expectation, default_bm);
                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
            }
-            Pat::TupleStruct { path: ref p, args: ref subpats } => {
+            Pat::TupleStruct { path: p, args: subpats } => {
                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
            }
-            Pat::Struct { path: ref p, args: ref fields } => {
+            Pat::Record { path: p, args: fields } => {
                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
            }
            Pat::Path(path) => {
@@ -817,7 +817,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let resolver = self.resolver.clone();
                self.infer_path_expr(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
            }
-            Pat::Bind { mode, name: _name, subpat } => {
+            Pat::Bind { mode, name: _, subpat } => {
                let mode = if mode == &BindingAnnotation::Unannotated {
                    default_bm
                } else {
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index e7e8825d1..9a0d2d8f9 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -3,7 +3,7 @@
 use super::{InferenceContext, Obligation};
 use crate::db::HirDatabase;
 use crate::ty::{
-    Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, TraitRef, Ty,
+    Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, TraitRef, Ty, TypeWalk,
 };
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 47d161277..f6f0137cf 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -8,7 +8,10 @@
 use std::iter;
 use std::sync::Arc;
-use super::{FnSig, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor};
+use super::{
+    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    TypeWalk,
+};
 use crate::{
    adt::VariantDef,
    generics::HasGenericParams,
@@ -62,7 +65,9 @@ impl Ty {
                let self_ty = Ty::Bound(0);
                let predicates = bounds
                    .iter()
-                    .map(|b| GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone()))
+                    .flat_map(|b| {
+                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
+                    })
                    .collect::<Vec<_>>();
                Ty::Dyn(predicates.into())
            }
@@ -70,7 +75,9 @@ impl Ty {
                let self_ty = Ty::Bound(0);
                let predicates = bounds
                    .iter()
-                    .map(|b| GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone()))
+                    .flat_map(|b| {
+                        GenericPredicate::from_type_bound(db, resolver, b, self_ty.clone())
+                    })
                    .collect::<Vec<_>>();
                Ty::Opaque(predicates.into())
            }
@@ -326,15 +333,6 @@ impl TraitRef {
        TraitRef { trait_, substs }
    }
-    pub(crate) fn from_where_predicate(
-        db: &impl HirDatabase,
-        resolver: &Resolver,
-        pred: &WherePredicate,
-    ) -> Option<TraitRef> {
-        let self_ty = Ty::from_hir(db, resolver, &pred.type_ref);
-        TraitRef::from_type_bound(db, resolver, &pred.bound, self_ty)
-    }
    pub(crate) fn from_type_bound(
        db: &impl HirDatabase,
        resolver: &Resolver,
@@ -349,26 +347,58 @@ impl TraitRef {
 }
 impl GenericPredicate {
-    pub(crate) fn from_where_predicate(
+    pub(crate) fn from_where_predicate<'a>(
-        db: &impl HirDatabase,
+        db: &'a impl HirDatabase,
-        resolver: &Resolver,
+        resolver: &'a Resolver,
-        where_predicate: &WherePredicate,
+        where_predicate: &'a WherePredicate,
-    ) -> GenericPredicate {
+    ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        TraitRef::from_where_predicate(db, &resolver, where_predicate)
+        let self_ty = Ty::from_hir(db, resolver, &where_predicate.type_ref);
-            .map_or(GenericPredicate::Error, GenericPredicate::Implemented)
+        GenericPredicate::from_type_bound(db, resolver, &where_predicate.bound, self_ty)
    }
-    pub(crate) fn from_type_bound(
+    pub(crate) fn from_type_bound<'a>(
-        db: &impl HirDatabase,
+        db: &'a impl HirDatabase,
-        resolver: &Resolver,
+        resolver: &'a Resolver,
-        bound: &TypeBound,
+        bound: &'a TypeBound,
        self_ty: Ty,
-    ) -> GenericPredicate {
+    ) -> impl Iterator<Item = GenericPredicate> + 'a {
-        TraitRef::from_type_bound(db, &resolver, bound, self_ty)
+        let trait_ref = TraitRef::from_type_bound(db, &resolver, bound, self_ty);
-            .map_or(GenericPredicate::Error, GenericPredicate::Implemented)
+        iter::once(trait_ref.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented))
+            .chain(
+                trait_ref.into_iter().flat_map(move |tr| {
+                    assoc_type_bindings_from_type_bound(db, resolver, bound, tr)
+                }),
+            )
    }
 }
+fn assoc_type_bindings_from_type_bound<'a>(
+    db: &'a impl HirDatabase,
+    resolver: &'a Resolver,
+    bound: &'a TypeBound,
+    trait_ref: TraitRef,