66 files changed, 1693 insertions, 429 deletions
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 64444ee3a..b39e60870 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -78,7 +78,7 @@ fn foo() {
 }
 fn bar(arg: &str, baz: Baz) {
-    unimplemented!()
+    todo!()
 }
 "#####,
@@ -180,7 +180,7 @@ trait Trait<T> {
 }
 impl Trait<u32> for () {
-    fn foo(&self) -> u32 { unimplemented!() }
+    fn foo(&self) -> u32 { todo!() }
 }
 "#####,
@@ -607,6 +607,21 @@ impl Walrus {
 }
 #[test]
+fn doctest_reorder_fields() {
+    check(
+        "reorder_fields",
+        r#####"
+struct Foo {foo: i32, bar: i32};
+const test: Foo = <|>Foo {bar: 0, foo: 1}
+"#####,
+        r#####"
+struct Foo {foo: i32, bar: i32};
+const test: Foo = Foo {foo: 1, bar: 0}
+"#####,
+    )
+}
+#[test]
 fn doctest_replace_if_let_with_match() {
    check(
        "replace_if_let_with_match",
diff --git a/crates/ra_assists/src/handlers/add_function.rs b/crates/ra_assists/src/handlers/add_function.rs
index 488bae08f..ad4ab66ed 100644
--- a/crates/ra_assists/src/handlers/add_function.rs
+++ b/crates/ra_assists/src/handlers/add_function.rs
@@ -29,7 +29,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 // }
 //
 // fn bar(arg: &str, baz: Baz) {
-//     unimplemented!()
+//     todo!()
 // }
 //
 // ```
@@ -80,7 +80,7 @@ impl FunctionBuilder {
        Some(Self { append_fn_at, fn_name, type_params, params })
    }
    fn render(self) -> Option<FunctionTemplate> {
-        let placeholder_expr = ast::make::expr_unimplemented();
+        let placeholder_expr = ast::make::expr_todo();
        let fn_body = ast::make::block_expr(vec![], Some(placeholder_expr));
        let fn_def = ast::make::fn_def(self.fn_name, self.type_params, self.params, fn_body);
        let fn_def = ast::make::add_newlines(2, fn_def);
@@ -225,7 +225,7 @@ fn foo() {
 }
 fn bar() {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -252,7 +252,7 @@ impl Foo {
 }
 fn bar() {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -276,7 +276,7 @@ fn foo1() {
 }
 fn bar() {
-    <|>unimplemented!()
+    <|>todo!()
 }
 fn foo2() {}
@@ -302,7 +302,7 @@ mod baz {
    }
    fn bar() {
-        <|>unimplemented!()
+        <|>todo!()
    }
 }
 ",
@@ -315,20 +315,20 @@ mod baz {
            add_function,
            r"
 struct Baz;
-fn baz() -> Baz { unimplemented!() }
+fn baz() -> Baz { todo!() }
 fn foo() {
    bar<|>(baz());
 }
 ",
            r"
 struct Baz;
-fn baz() -> Baz { unimplemented!() }
+fn baz() -> Baz { todo!() }
 fn foo() {
    bar(baz());
 }
 fn bar(baz: Baz) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        );
@@ -361,7 +361,7 @@ impl Baz {
 }
 fn bar(baz: Baz) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -382,7 +382,7 @@ fn foo() {
 }
 fn bar(arg: &str) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 "#,
        )
@@ -403,7 +403,7 @@ fn foo() {
 }
 fn bar(arg: char) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 "#,
        )
@@ -424,7 +424,7 @@ fn foo() {
 }
 fn bar(arg: i32) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -445,7 +445,7 @@ fn foo() {
 }
 fn bar(arg: u8) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -470,7 +470,7 @@ fn foo() {
 }
 fn bar(x: u8) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -493,7 +493,7 @@ fn foo() {
 }
 fn bar(worble: ()) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -506,7 +506,7 @@ fn bar(worble: ()) {
            r"
 trait Foo {}
 fn foo() -> impl Foo {
-    unimplemented!()
+    todo!()
 }
 fn baz() {
    <|>bar(foo())
@@ -515,14 +515,14 @@ fn baz() {
            r"
 trait Foo {}
 fn foo() -> impl Foo {
-    unimplemented!()
+    todo!()
 }
 fn baz() {
    bar(foo())
 }
 fn bar(foo: impl Foo) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -556,7 +556,7 @@ mod Foo {
    }
    fn bar(baz: super::Baz::Bof) {
-        <|>unimplemented!()
+        <|>todo!()
    }
 }
 ",
@@ -580,7 +580,7 @@ fn foo<T>(t: T) {
 }
 fn bar<T>(t: T) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -611,7 +611,7 @@ fn foo() {
 }
 fn bar(arg: fn() -> Baz) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -636,7 +636,7 @@ fn foo() {
 }
 fn bar(closure: impl Fn(i64) -> i64) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -657,7 +657,7 @@ fn foo() {
 }
 fn bar(baz: ()) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -682,7 +682,7 @@ fn foo() {
 }
 fn bar(baz_1: Baz, baz_2: Baz) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 ",
        )
@@ -707,7 +707,7 @@ fn foo() {
 }
 fn bar(baz_1: Baz, baz_2: Baz, arg_1: &str, arg_2: &str) {
-    <|>unimplemented!()
+    <|>todo!()
 }
 "#,
        )
@@ -779,7 +779,7 @@ impl Foo {
        self.bar();
    }
    fn bar(&self) {
-        unimplemented!();
+        todo!();
    }
 }
        ",
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index 722f207e2..2d6d44980 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -40,7 +40,7 @@ enum AddMissingImplMembersMode {
 // }
 //
 // impl Trait<u32> for () {
-//     fn foo(&self) -> u32 { unimplemented!() }
+//     fn foo(&self) -> u32 { todo!() }
 //
 // }
 // ```
@@ -165,7 +165,7 @@ fn add_missing_impl_members_inner(
 fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
    if fn_def.body().is_none() {
-        fn_def.with_body(make::block_from_expr(make::expr_unimplemented()))
+        fn_def.with_body(make::block_from_expr(make::expr_todo()))
    } else {
        fn_def
    }
@@ -215,8 +215,8 @@ impl Foo for S {
    fn bar(&self) {}
    <|>type Output;
    const CONST: usize = 42;
-    fn foo(&self) { unimplemented!() }
+    fn foo(&self) { todo!() }
-    fn baz(&self) { unimplemented!() }
+    fn baz(&self) { todo!() }
 }",
        );
@@ -250,7 +250,7 @@ struct S;
 impl Foo for S {
    fn bar(&self) {}
-    <|>fn foo(&self) { unimplemented!() }
+    <|>fn foo(&self) { todo!() }
 }",
        );
@@ -268,7 +268,7 @@ impl Foo for S { <|> }",
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { unimplemented!() }
+    <|>fn foo(&self) { todo!() }
 }",
        );
    }
@@ -285,7 +285,7 @@ impl Foo<u32> for S { <|> }",
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl Foo<u32> for S {
-    <|>fn foo(&self, t: u32) -> &u32 { unimplemented!() }
+    <|>fn foo(&self, t: u32) -> &u32 { todo!() }
 }",
        );
    }
@@ -302,7 +302,7 @@ impl<U> Foo<U> for S { <|> }",
 trait Foo<T> { fn foo(&self, t: T) -> &T; }
 struct S;
 impl<U> Foo<U> for S {
-    <|>fn foo(&self, t: U) -> &U { unimplemented!() }
+    <|>fn foo(&self, t: U) -> &U { todo!() }
 }",
        );
    }
@@ -319,7 +319,7 @@ impl Foo for S {}<|>",
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    <|>fn foo(&self) { unimplemented!() }
+    <|>fn foo(&self) { todo!() }
 }",
        )
    }
@@ -342,7 +342,7 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar) { unimplemented!() }
+    <|>fn foo(&self, bar: foo::Bar) { todo!() }
 }",
        );
    }
@@ -365,7 +365,7 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { unimplemented!() }
+    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
 }",
        );
    }
@@ -388,7 +388,7 @@ mod foo {
 }
 struct S;
 impl foo::Foo<u32> for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>) { unimplemented!() }
+    <|>fn foo(&self, bar: foo::Bar<u32>) { todo!() }
 }",
        );
    }
@@ -414,7 +414,7 @@ mod foo {
 struct Param;
 struct S;
 impl foo::Foo<Param> for S {
-    <|>fn foo(&self, bar: Param) { unimplemented!() }
+    <|>fn foo(&self, bar: Param) { todo!() }
 }",
        );
    }
@@ -439,7 +439,7 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<u32>::Assoc) { unimplemented!() }
+    <|>fn foo(&self, bar: foo::Bar<u32>::Assoc) { todo!() }
 }",
        );
    }
@@ -464,7 +464,7 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: foo::Bar<foo::Baz>) { unimplemented!() }
+    <|>fn foo(&self, bar: foo::Bar<foo::Baz>) { todo!() }
 }",
        );
    }
@@ -487,7 +487,7 @@ mod foo {
 }
 struct S;
 impl foo::Foo for S {
-    <|>fn foo(&self, bar: dyn Fn(u32) -> i32) { unimplemented!() }
+    <|>fn foo(&self, bar: dyn Fn(u32) -> i32) { todo!() }
 }",
        );
    }
@@ -544,7 +544,7 @@ trait Foo {
 struct S;
 impl Foo for S {
    <|>type Output;
-    fn foo(&self) { unimplemented!() }
+    fn foo(&self) { todo!() }
 }"#,
        )
    }
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index 0958f52f1..ef0ce0586 100644
--- a/crates/ra_assists/src/handlers/merge_imports.rs
+++ b/crates/ra_assists/src/handlers/merge_imports.rs
@@ -1,7 +1,7 @@
 use std::iter::successors;
 use ra_syntax::{
-    algo::{neighbor, SyntaxRewriter},
+    algo::{neighbor, skip_trivia_token, SyntaxRewriter},
    ast::{self, edit::AstNodeEdit, make},
    AstNode, Direction, InsertPosition, SyntaxElement, T,
 };
@@ -72,9 +72,18 @@ fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option<ast::UseTre
    let lhs = old.split_prefix(&lhs_prefix);
    let rhs = new.split_prefix(&rhs_prefix);
+    let should_insert_comma = lhs
+        .use_tree_list()?
+        .r_curly_token()
+        .and_then(|it| skip_trivia_token(it.prev_token()?, Direction::Prev))
+        .map(|it| it.kind() != T![,])
+        .unwrap_or(true);
    let mut to_insert: Vec<SyntaxElement> = Vec::new();
-    to_insert.push(make::token(T![,]).into());
+    if should_insert_comma {
-    to_insert.push(make::tokens::single_space().into());
+        to_insert.push(make::token(T![,]).into());
+        to_insert.push(make::tokens::single_space().into());
+    }
    to_insert.extend(
        rhs.use_tree_list()?
            .syntax()
@@ -247,4 +256,22 @@ use {
 ",
        );
    }
+    #[test]
+    fn test_double_comma() {
+        check_assist(
+            merge_imports,
+            r"
+use foo::bar::baz;
+use foo::<|>{
+    FooBar,
+};
+",
+            r"
+use foo::{<|>
+    FooBar,
+bar::baz};
+",
+        )
+    }
 }
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
new file mode 100644
index 000000000..5cbb98d73
--- /dev/null
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -0,0 +1,224 @@
+use std::collections::HashMap;
+use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
+use itertools::Itertools;
+use ra_ide_db::RootDatabase;
+use ra_syntax::{
+    algo,
+    ast::{self, Path, RecordLit, RecordPat},
+    match_ast, AstNode, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode,
+};
+use crate::{
+    assist_ctx::{Assist, AssistCtx},
+    AssistId,
+};
+// Assist: reorder_fields
+//
+// Reorder the fields of record literals and record patterns in the same order as in
+// the definition.
+//
+// ```
+// struct Foo {foo: i32, bar: i32};
+// const test: Foo = <|>Foo {bar: 0, foo: 1}
+// ```
+// ->
+// ```
+// struct Foo {foo: i32, bar: i32};
+// const test: Foo = Foo {foo: 1, bar: 0}
+// ```
+//
+pub(crate) fn reorder_fields(ctx: AssistCtx) -> Option<Assist> {
+    reorder::<RecordLit>(ctx.clone()).or_else(|| reorder::<RecordPat>(ctx))
+}
+fn reorder<R: AstNode>(ctx: AssistCtx) -> Option<Assist> {
+    let record = ctx.find_node_at_offset::<R>()?;
+    let path = record.syntax().children().find_map(Path::cast)?;
+    let ranks = compute_fields_ranks(&path, &ctx)?;
+    let fields = get_fields(&record.syntax());
+    let sorted_fields = sorted_by_rank(&fields, |node| {
+        *ranks.get(&get_field_name(node)).unwrap_or(&usize::max_value())
+    });
+    if sorted_fields == fields {
+        return None;
+    }
+    ctx.add_assist(AssistId("reorder_fields"), "Reorder record fields", |edit| {
+        for (old, new) in fields.iter().zip(&sorted_fields) {
+            algo::diff(old, new).into_text_edit(edit.text_edit_builder());
+        }
+        edit.target(record.syntax().text_range())
+    })
+}
+fn get_fields_kind(node: &SyntaxNode) -> Vec<SyntaxKind> {
+    match node.kind() {
+        RECORD_LIT => vec![RECORD_FIELD],
+        RECORD_PAT => vec![RECORD_FIELD_PAT, BIND_PAT],
+        _ => vec![],
+    }
+}
+fn get_field_name(node: &SyntaxNode) -> String {
+    let res = match_ast! {
+        match node {
+            ast::RecordField(field) => field.field_name().map(|it| it.to_string()),
+            ast::RecordFieldPat(field) => field.field_name().map(|it| it.to_string()),
+            _ => None,
+        }
+    };
+    res.unwrap_or_default()
+}
+fn get_fields(record: &SyntaxNode) -> Vec<SyntaxNode> {
+    let kinds = get_fields_kind(record);
+    record.children().flat_map(|n| n.children()).filter(|n| kinds.contains(&n.kind())).collect()
+}
+fn sorted_by_rank(
+    fields: &[SyntaxNode],
+    get_rank: impl Fn(&SyntaxNode) -> usize,
+) -> Vec<SyntaxNode> {
+    fields.iter().cloned().sorted_by_key(get_rank).collect()
+}
+fn struct_definition(path: &ast::Path, sema: &Semantics<RootDatabase>) -> Option<Struct> {
+    match sema.resolve_path(path) {
+        Some(PathResolution::Def(ModuleDef::Adt(Adt::Struct(s)))) => Some(s),
+        _ => None,
+    }
+}
+fn compute_fields_ranks(path: &Path, ctx: &AssistCtx) -> Option<HashMap<String, usize>> {
+    Some(
+        struct_definition(path, ctx.sema)?
+            .fields(ctx.db)
+            .iter()
+            .enumerate()
+            .map(|(idx, field)| (field.name(ctx.db).to_string(), idx))
+            .collect(),
+    )
+}
+#[cfg(test)]
+mod tests {
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn not_applicable_if_sorted() {
+        check_assist_not_applicable(
+            reorder_fields,
+            r#"
+        struct Foo {
+            foo: i32,
+            bar: i32,
+        }
+        const test: Foo = <|>Foo { foo: 0, bar: 0 };
+        "#,
+        )
+    }
+    #[test]
+    fn trivial_empty_fields() {
+        check_assist_not_applicable(
+            reorder_fields,
+            r#"
+        struct Foo {};
+        const test: Foo = <|>Foo {}
+        "#,
+        )
+    }
+    #[test]
+    fn reorder_struct_fields() {
+        check_assist(
+            reorder_fields,
+            r#"
+        struct Foo {foo: i32, bar: i32};
+        const test: Foo = <|>Foo {bar: 0, foo: 1}
+        "#,
+            r#"
+        struct Foo {foo: i32, bar: i32};
+        const test: Foo = <|>Foo {foo: 1, bar: 0}
+        "#,
+        )
+    }
+    #[test]
+    fn reorder_struct_pattern() {
+        check_assist(
+            reorder_fields,
+            r#"
+        struct Foo { foo: i64, bar: i64, baz: i64 }
+        fn f(f: Foo) -> {
+            match f {
+                <|>Foo { baz: 0, ref mut bar, .. } => (),
+                _ => ()
+            }
+        }
+        "#,
+            r#"
+        struct Foo { foo: i64, bar: i64, baz: i64 }
+        fn f(f: Foo) -> {
+            match f {
+                <|>Foo { ref mut bar, baz: 0, .. } => (),
+                _ => ()
+            }
+        }
+        "#,
+        )
+    }
+    #[test]
+    fn reorder_with_extra_field() {
+        check_assist(
+            reorder_fields,
+            r#"
+            struct Foo {
+                foo: String,
+                bar: String,
+            }
+            impl Foo {
+                fn new() -> Foo {
+                    let foo = String::new();
+                    <|>Foo {
+                        bar: foo.clone(),
+                        extra: "Extra field",
+                        foo,
+                    }
+                }
+            }
+            "#,
+            r#"
+            struct Foo {
+                foo: String,
+                bar: String,
+            }
+            impl Foo {
+                fn new() -> Foo {
+                    let foo = String::new();
+                    <|>Foo {
+                        foo,
+                        bar: foo.clone(),
+                        extra: "Extra field",
+                    }
+                }
+            }
+            "#,
+        )
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 5ba5254fd..a00136da1 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -129,6 +129,7 @@ mod handlers {
    mod replace_unwrap_with_match;
    mod split_import;
    mod add_from_impl_for_enum;
+    mod reorder_fields;
    pub(crate) fn all() -> &'static [AssistHandler] {
        &[
@@ -170,6 +171,7 @@ mod handlers {
            // These are manually sorted for better priorities
            add_missing_impl_members::add_missing_impl_members,
            add_missing_impl_members::add_missing_default_members,
+            reorder_fields::reorder_fields,
        ]
    }
 }
diff --git a/crates/ra_flycheck/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index c9a9ddc12..76e5cada4 100644
--- a/crates/ra_flycheck/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -13,4 +13,4 @@ serde_json = "1.0.48"
 jod-thread = "0.1.1"
 [dev-dependencies]
-insta = "0.15.0"
+insta = "0.16.0"
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 9baebf643..3801fce23 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -25,7 +25,7 @@ use hir_ty::{
    autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
    Canonical, InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
-use ra_db::{CrateId, Edition, FileId};
+use ra_db::{CrateId, CrateName, Edition, FileId};
 use ra_prof::profile;
 use ra_syntax::{
    ast::{self, AttrsOwner, NameOwner},
@@ -91,6 +91,10 @@ impl Crate {
        db.crate_graph()[self.id].edition
    }
+    pub fn display_name(self, db: &dyn HirDatabase) -> Option<CrateName> {
+        db.crate_graph()[self.id].display_name.as_ref().cloned()
+    }
    pub fn all(db: &dyn HirDatabase) -> Vec<Crate> {
        db.crate_graph().iter().map(|id| Crate { id }).collect()
    }
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 226fb4534..58ae6ce41 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -139,7 +139,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        field: &ast::FieldExpr,
-    ) -> Option<crate::StructField> {
+    ) -> Option<StructField> {
        let expr_id = self.expr_id(db, &field.clone().into())?;
        self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
    }
@@ -148,21 +148,19 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        field: &ast::RecordField,
-    ) -> Option<(crate::StructField, Option<Local>)> {
+    ) -> Option<(StructField, Option<Local>)> {
-        let (expr_id, local) = match field.expr() {
+        let expr = field.expr()?;
-            Some(it) => (self.expr_id(db, &it)?, None),
+        let expr_id = self.expr_id(db, &expr)?;
-            None => {
+        let local = if field.name_ref().is_some() {
-                let src = InFile { file_id: self.file_id, value: field };
+            None
-                let expr_id = self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?;
+        } else {
-                let local_name = field.name_ref()?.as_name();
+            let local_name = field.field_name()?.as_name();
-                let path = ModPath::from_segments(PathKind::Plain, once(local_name));
+            let path = ModPath::from_segments(PathKind::Plain, once(local_name));
-                let local = match self.resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) {
+            match self.resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) {
-                    Some(ValueNs::LocalBinding(pat_id)) => {
+                Some(ValueNs::LocalBinding(pat_id)) => {
-                        Some(Local { pat_id, parent: self.resolver.body_owner()? })
+                    Some(Local { pat_id, parent: self.resolver.body_owner()? })
-                    }
+                }
-                    _ => None,
+                _ => None,
-                };
-                (expr_id, local)
            }
        };
        let struct_field = self.infer.as_ref()?.record_field_resolution(expr_id)?;
@@ -319,8 +317,7 @@ fn scope_for_offset(
            if source.file_id != offset.file_id {
                return None;
            }
-            let syntax_node_ptr =
+            let syntax_node_ptr = source.value.syntax_node_ptr();
-                source.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
            Some((syntax_node_ptr, scope))
        })
        // find containing scope
@@ -399,8 +396,7 @@ fn adjust(
            if source.file_id != file_id {
                return None;
            }
-            let syntax_node_ptr =
+            let syntax_node_ptr = source.value.syntax_node_ptr();
-                source.value.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
            Some((syntax_node_ptr, scope))
        })
        .map(|(ptr, scope)| (ptr.range(), scope))
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index 56e791e3e..b85358308 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -28,4 +28,4 @@ ra_cfg = { path = "../ra_cfg" }
 tt = { path = "../ra_tt", package = "ra_tt" }
 [dev-dependencies]
-insta = "0.15.0"
+insta = "0.16.0"
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index be4b0accb..7c0d93691 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -4,7 +4,6 @@ use std::sync::Arc;
 use either::Either;
 use hir_expand::{
-    hygiene::Hygiene,
    name::{AsName, Name},
    InFile,
 };
@@ -13,7 +12,7 @@ use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 use crate::{
-    attr::Attrs, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace,
+    body::CfgExpander, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace,
    type_ref::TypeRef, visibility::RawVisibility, EnumId, HasModule, LocalEnumVariantId,
    LocalStructFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
 };
@@ -125,8 +124,9 @@ fn lower_enum(
 impl VariantData {
    fn new(db: &dyn DefDatabase, flavor: InFile<ast::StructKind>, module_id: ModuleId) -> Self {
+        let mut expander = CfgExpander::new(db, flavor.file_id, module_id.krate);
        let mut trace = Trace::new_for_arena();
-        match lower_struct(db, &mut trace, &flavor, module_id) {
+        match lower_struct(db, &mut expander, &mut trace, &flavor) {
            StructKind::Tuple => VariantData::Tuple(trace.into_arena()),
            StructKind::Record => VariantData::Record(trace.into_arena()),
            StructKind::Unit => VariantData::Unit,
@@ -178,8 +178,9 @@ impl HasChildSource for VariantId {
                it.lookup(db).container.module(db),
            ),
        };
+        let mut expander = CfgExpander::new(db, src.file_id, module_id.krate);
        let mut trace = Trace::new_for_map();
-        lower_struct(db, &mut trace, &src, module_id);
+        lower_struct(db, &mut expander, &mut trace, &src);
        src.with_value(trace.into_map())
    }
 }
@@ -193,16 +194,15 @@ pub enum StructKind {
 fn lower_struct(
    db: &dyn DefDatabase,
+    expander: &mut CfgExpander,
    trace: &mut Trace<StructFieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
    ast: &InFile<ast::StructKind>,
-    module_id: ModuleId,
 ) -> StructKind {
-    let crate_graph = db.crate_graph();
    match &ast.value {
        ast::StructKind::Tuple(fl) => {
            for (i, fd) in fl.fields().enumerate() {
-                let attrs = Attrs::new(&fd, &Hygiene::new(db.upcast(), ast.file_id));
+                let attrs = expander.parse_attrs(&fd);
-                if !attrs.is_cfg_enabled(&crate_graph[module_id.krate].cfg_options) {
+                if !expander.is_cfg_enabled(&attrs) {
                    continue;
                }
@@ -219,8 +219,8 @@ fn lower_struct(
        }
        ast::StructKind::Record(fl) => {
            for fd in fl.fields() {
-                let attrs = Attrs::new(&fd, &Hygiene::new(db.upcast(), ast.file_id));
+                let attrs = expander.parse_attrs(&fd);
-                if !attrs.is_cfg_enabled(&crate_graph[module_id.krate].cfg_options) {
+                if !expander.is_cfg_enabled(&attrs) {
                    continue;
                }
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 7b0c506b1..2f2e3e5ba 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -93,6 +93,7 @@ impl Attrs {
    }
    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> bool {
+        // FIXME: handle cfg_attr :-)
        self.by_key("cfg").tt_values().all(|tt| cfg_options.is_cfg_enabled(tt) != Some(false))
    }
 }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index e09996c6f..eafaf48c1 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -9,11 +9,14 @@ use drop_bomb::DropBomb;
 use either::Either;
 use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroDefId};
 use ra_arena::{map::ArenaMap, Arena};
+use ra_cfg::CfgOptions;
+use ra_db::CrateId;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
 use crate::{
+    attr::Attrs,
    db::DefDatabase,
    expr::{Expr, ExprId, Pat, PatId},
    item_scope::BuiltinShadowMode,
@@ -24,25 +27,59 @@ use crate::{
    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
 };
+/// A subser of Exander that only deals with cfg attributes. We only need it to
+/// avoid cyclic queries in crate def map during enum processing.
+pub(crate) struct CfgExpander {
+    cfg_options: CfgOptions,
+    hygiene: Hygiene,
+}
 pub(crate) struct Expander {
+    cfg_expander: CfgExpander,
    crate_def_map: Arc<CrateDefMap>,
    current_file_id: HirFileId,
-    hygiene: Hygiene,
    ast_id_map: Arc<AstIdMap>,
    module: ModuleId,
    recursive_limit: usize,
 }
+impl CfgExpander {
+    pub(crate) fn new(
+        db: &dyn DefDatabase,
+        current_file_id: HirFileId,
+        krate: CrateId,
+    ) -> CfgExpander {
+        let hygiene = Hygiene::new(db.upcast(), current_file_id);
+        let cfg_options = db.crate_graph()[krate].cfg_options.clone();
+        CfgExpander { cfg_options, hygiene }
+    }
+    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
+        Attrs::new(owner, &self.hygiene)
+    }
+    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
+        attrs.is_cfg_enabled(&self.cfg_options)
+    }
+}
 impl Expander {
    pub(crate) fn new(
        db: &dyn DefDatabase,
        current_file_id: HirFileId,
        module: ModuleId,
    ) -> Expander {
+        let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
        let crate_def_map = db.crate_def_map(module.krate);
-        let hygiene = Hygiene::new(db.upcast(), current_file_id);
        let ast_id_map = db.ast_id_map(current_file_id);
-        Expander { crate_def_map, current_file_id, hygiene, ast_id_map, module, recursive_limit: 0 }
+        Expander {
+            cfg_expander,
+            crate_def_map,
+            current_file_id,
+            ast_id_map,
+            module,
+            recursive_limit: 0,
+        }
    }
    pub(crate) fn enter_expand<T: ast::AstNode>(
@@ -75,7 +112,7 @@ impl Expander {
                        ast_id_map: mem::take(&mut self.ast_id_map),
                        bomb: DropBomb::new("expansion mark dropped"),
                    };
-                    self.hygiene = Hygiene::new(db.upcast(), file_id);
+                    self.cfg_expander.hygiene = Hygiene::new(db.upcast(), file_id);
                    self.current_file_id = file_id;
                    self.ast_id_map = db.ast_id_map(file_id);
                    self.recursive_limit += 1;
@@ -91,7 +128,7 @@ impl Expander {
    }
    pub(crate) fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
-        self.hygiene = Hygiene::new(db.upcast(), mark.file_id);
+        self.cfg_expander.hygiene = Hygiene::new(db.upcast(), mark.file_id);
        self.current_file_id = mark.file_id;
        self.ast_id_map = mem::take(&mut mark.ast_id_map);
        self.recursive_limit -= 1;
@@ -102,8 +139,16 @@ impl Expander {
        InFile { file_id: self.current_file_id, value }
    }
+    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
+        self.cfg_expander.parse_attrs(owner)
+    }
+    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
+        self.cfg_expander.is_cfg_enabled(attrs)
+    }
    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
-        Path::from_src(path, &self.hygiene)
+        Path::from_src(path, &self.cfg_expander.hygiene)
    }
    fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<MacroDefId> {
@@ -142,7 +187,7 @@ pub struct Body {
    pub item_scope: ItemScope,
 }
-pub type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;
+pub type ExprPtr = AstPtr<ast::Expr>;
 pub type ExprSource = InFile<ExprPtr>;
 pub type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
@@ -240,7 +285,7 @@ impl BodySourceMap {
    }
    pub fn node_expr(&self, node: InFile<&ast::Expr>) -> Option<ExprId> {
-        let src = node.map(|it| Either::Left(AstPtr::new(it)));
+        let src = node.map(|it| AstPtr::new(it));
        self.expr_map.get(&src).cloned()
    }
@@ -249,11 +294,6 @@ impl BodySourceMap {
        self.expansions.get(&src).cloned()
    }
-    pub fn field_init_shorthand_expr(&self, node: InFile<&ast::RecordField>) -> Option<ExprId> {
-        let src = node.map(|it| Either::Right(AstPtr::new(it)));
-        self.expr_map.get(&src).cloned()
-    }
    pub fn pat_syntax(&self, pat: PatId) -> Result<PatSource, SyntheticSyntax> {
        self.pat_map_back[pat].clone()
    }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 9d6ee095e..79abe55ce 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -2,9 +2,7 @@
 //! representation.
 use either::Either;
 use hir_expand::{
-    hygiene::Hygiene,
    name::{name, AsName, Name},
    MacroDefId, MacroDefKind,
 };
@@ -18,10 +16,8 @@ use ra_syntax::{
 };
 use test_utils::tested_by;
-use super::{ExprSource, PatSource};
 use crate::{
    adt::StructKind,
-    attr::Attrs,
    body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
    builtin_type::{BuiltinFloat, BuiltinInt},
    db::DefDatabase,
@@ -31,12 +27,14 @@ use crate::{
    },
    item_scope::BuiltinShadowMode,
    path::GenericArgs,
-    path::Path,
    type_ref::{Mutability, TypeRef},
-    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, HasModule, Intern,
+    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
-    ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
+use super::{ExprSource, PatSource};
+use ast::AstChildren;
 pub(super) fn lower(
    db: &dyn DefDatabase,
    def: DefWithBodyId,
@@ -104,7 +102,6 @@ impl ExprCollector<'_> {
    }
    fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
-        let ptr = Either::Left(ptr);
        let src = self.expander.to_source(ptr);
        let id = self.make_expr(expr, Ok(src.clone()));
        self.source_map.expr_map.insert(src, id);
@@ -115,13 +112,6 @@ impl ExprCollector<'_> {
    fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
        self.make_expr(expr, Err(SyntheticSyntax))
    }
-    fn alloc_expr_field_shorthand(&mut self, expr: Expr, ptr: AstPtr<ast::RecordField>) -> ExprId {
-        let ptr = Either::Right(ptr);
-        let src = self.expander.to_source(ptr);
-        let id = self.make_expr(expr, Ok(src.clone()));
-        self.source_map.expr_map.insert(src, id);
-        id
-    }
    fn empty_block(&mut self) -> ExprId {
        self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None })
    }
@@ -291,7 +281,7 @@ impl ExprCollector<'_> {
            ast::Expr::ParenExpr(e) => {
                let inner = self.collect_expr_opt(e.expr());
                // make the paren expr point to the inner expression as well
-                let src = self.expander.to_source(Either::Left(syntax_ptr));
+                let src = self.expander.to_source(syntax_ptr);
                self.source_map.expr_map.insert(src, inner);
                inner
            }
@@ -300,7 +290,6 @@ impl ExprCollector<'_> {
                self.alloc_expr(Expr::Return { expr }, syntax_ptr)
            }
            ast::Expr::RecordLit(e) => {
-                let crate_graph = self.db.crate_graph();
                let path = e.path().and_then(|path| self.expander.parse_path(path));
                let mut field_ptrs = Vec::new();
                let record_lit = if let Some(nfl) = e.record_field_list() {
@@ -308,31 +297,17 @@ impl ExprCollector<'_> {
                        .fields()
                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                        .filter_map(|field| {
-                            let module_id = ContainerId::DefWithBodyId(self.def).module(self.db);
+                            let attrs = self.expander.parse_attrs(&field);
-                            let attrs = Attrs::new(
+                            if !self.expander.is_cfg_enabled(&attrs) {
-                                &field,
-                                &Hygiene::new(self.db.upcast(), self.expander.current_file_id),
-                            );
-                            if !attrs.is_cfg_enabled(&crate_graph[module_id.krate].cfg_options) {
                                return None;
                            }
+                            let name = field.field_name()?.as_name();
                            Some(RecordLitField {
-                                name: field
+                                name,
-                                    .name_ref()
+                                expr: match field.expr() {
-                                    .map(|nr| nr.as_name())
+                                    Some(e) => self.collect_expr(e),
-                                    .unwrap_or_else(Name::missing),
+                                    None => self.missing_expr(),
-                                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()
                                },
                            })
                        })
@@ -624,8 +599,8 @@ impl ExprCollector<'_> {
            }
            ast::Pat::TupleStructPat(p) => {
                let path = p.path().and_then(|path| self.expander.parse_path(path));
-                let args = p.args().map(|p| self.collect_pat(p)).collect();
+                let (args, ellipsis) = self.collect_tuple_pat(p.args());
-                Pat::TupleStruct { path, args }
+                Pat::TupleStruct { path, args, ellipsis }
            }
            ast::Pat::RefPat(p) => {
                let pat = self.collect_pat_opt(p.pat());
@@ -642,10 +617,10 @@ impl ExprCollector<'_> {
            }
            ast::Pat::ParenPat(p) => return self.collect_pat_opt(p.pat()),
            ast::Pat::TuplePat(p) => {
-                let args = p.args().map(|p| self.collect_pat(p)).collect();
+                let (args, ellipsis) = self.collect_tuple_pat(p.args());
-                Pat::Tuple(args)
+                Pat::Tuple { args, ellipsis }
            }
-            ast::Pat::PlaceholderPat(_) | ast::Pat::DotDotPat(_) => Pat::Wild,
+            ast::Pat::PlaceholderPat(_) => Pat::Wild,
            ast::Pat::RecordPat(p) => {
                let path = p.path().and_then(|path| self.expander.parse_path(path));
                let record_field_pat_list =
@@ -663,7 +638,7 @@ impl ExprCollector<'_> {
                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();
+                    let name = f.field_name()?.as_name();
                    Some(RecordFieldPat { name, pat })
                });
                fields.extend(iter);
@@ -691,7 +666,9 @@ impl ExprCollector<'_> {
                    Pat::Missing
                }
            }
+            ast::Pat::DotDotPat(_) => unreachable!(
+                "`DotDotPat` requires special handling and should not be mapped to a Pat."
+            ),
            // FIXME: implement
            ast::Pat::BoxPat(_) | ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
        };
@@ -706,6 +683,19 @@ impl ExprCollector<'_> {
            self.missing_pat()
        }
    }
+    fn collect_tuple_pat(&mut self, args: AstChildren<ast::Pat>) -> (Vec<PatId>, Option<usize>) {
+        // Find the location of the `..`, if there is one. Note that we do not
+        // consider the possiblity of there being multiple `..` here.
+        let ellipsis = args.clone().position(|p| matches!(p, ast::Pat::DotDotPat(_)));
+        // We want to skip the `..` pattern here, since we account for it above.
+        let args = args
+            .filter(|p| !matches!(p, ast::Pat::DotDotPat(_)))
+            .map(|p| self.collect_pat(p))
+            .collect();
+        (args, ellipsis)
+    }
 }
 impl From<ast::BinOp> for BinaryOp {
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index b8fbf0ed4..ccb682f9a 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -9,18 +9,19 @@ use hir_expand::{
 };
 use ra_prof::profile;
 use ra_syntax::ast::{
-    self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner, VisibilityOwner,
+    self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner, TypeBoundsOwner,
+    VisibilityOwner,
 };
 use crate::{
    attr::Attrs,
    db::DefDatabase,
-    path::{path, GenericArgs, Path},
+    path::{path, AssociatedTypeBinding, GenericArgs, Path},
    src::HasSource,
    type_ref::{Mutability, TypeBound, TypeRef},
    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, Expander, FunctionId, FunctionLoc, HasModule,
-    ImplId, Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+    ImplId, Intern, Lookup, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -95,7 +96,11 @@ fn desugar_future_path(orig: TypeRef) -> Path {
    let path = path![std::future::Future];
    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
    let mut last = GenericArgs::empty();
-    last.bindings.push((name![Output], orig));
+    last.bindings.push(AssociatedTypeBinding {
+        name: name![Output],
+        type_ref: Some(orig),
+        bounds: Vec::new(),
+    });
    generic_args.push(Some(Arc::new(last)));
    Path::from_known_path(path, generic_args)
@@ -106,6 +111,7 @@ pub struct TypeAliasData {
    pub name: Name,
    pub type_ref: Option<TypeRef>,
    pub visibility: RawVisibility,
+    pub bounds: Vec<TypeBound>,
 }
 impl TypeAliasData {
@@ -118,9 +124,17 @@ impl TypeAliasData {
        let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
        let type_ref = node.value.type_ref().map(TypeRef::from_ast);
        let vis_default = RawVisibility::default_for_container(loc.container);
-        let visibility =
+        let visibility = RawVisibility::from_ast_with_default(
-            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
+            db,
-        Arc::new(TypeAliasData { name, type_ref, visibility })
+            vis_default,
+            node.as_ref().map(|n| n.visibility()),
+        );
+        let bounds = if let Some(bound_list) = node.value.type_bound_list() {
+            bound_list.bounds().map(TypeBound::from_ast).collect()
+        } else {
+            Vec::new()
+        };
+        Arc::new(TypeAliasData { name, type_ref, visibility, bounds })
    }
 }
@@ -218,10 +232,17 @@ impl ImplData {
        let mut items = Vec::new();
        if let Some(item_list) = src.value.item_list() {
-            items.extend(collect_impl_items(db, item_list.impl_items(), src.file_id, id));
+            let mut expander = Expander::new(db, impl_loc.ast_id.file_id, module_id);
+            items.extend(collect_impl_items(
+                db,
+                &mut expander,
+                item_list.impl_items(),
+                src.file_id,
+                id,
+            ));
            items.extend(collect_impl_items_in_macros(
                db,
-                module_id,
+                &mut expander,
                &src.with_value(item_list),
                id,
            ));
@@ -268,18 +289,17 @@ impl ConstData {
 fn collect_impl_items_in_macros(
    db: &dyn DefDatabase,
-    module_id: ModuleId,
+    expander: &mut Expander,
    impl_def: &InFile<ast::ItemList>,
    id: ImplId,
 ) -> Vec<AssocItemId> {
-    let mut expander = Expander::new(db, impl_def.file_id, module_id);
    let mut res = Vec::new();
    // We set a limit to protect against infinite recursion
    let limit = 100;
    for m in impl_def.value.syntax().children().filter_map(ast::MacroCall::cast) {
-        res.extend(collect_impl_items_in_macro(db, &mut expander, m, id, limit))
+        res.extend(collect_impl_items_in_macro(db, expander, m, id, limit))
    }
    res
@@ -300,6 +320,7 @@ fn collect_impl_items_in_macro(
        let items: InFile<ast::MacroItems> = expander.to_source(items);
        let mut res = collect_impl_items(
            db,
+            expander,
            items.value.items().filter_map(|it| ImplItem::cast(it.syntax().clone())),
            items.file_id,
            id,
@@ -319,32 +340,26 @@ fn collect_impl_items_in_macro(
 fn collect_impl_items(
    db: &dyn DefDatabase,
+    expander: &mut Expander,
    impl_items: impl Iterator<Item = ImplItem>,
    file_id: crate::HirFileId,
    id: ImplId,
 ) -> Vec<AssocItemId> {
    let items = db.ast_id_map(file_id);
-    let crate_graph = db.crate_graph();
-    let module_id = id.lookup(db).container.module(db);
    impl_items
        .filter_map(|item_node| match item_node {
            ast::ImplItem::FnDef(it) => {
+                let attrs = expander.parse_attrs(&it);
+                if !expander.is_cfg_enabled(&attrs) {
+                    return None;
+                }
                let def = FunctionLoc {
                    container: AssocContainerId::ImplId(id),
                    ast_id: AstId::new(file_id, items.ast_id(&it)),
                }
                .intern(db);
+                Some(def.into())
-                if !db
-                    .function_data(def)
-                    .attrs
-                    .is_cfg_enabled(&crate_graph[module_id.krate].cfg_options)
-                {
-                    None
-                } else {
-                    Some(def.into())
-                }
            }
            ast::ImplItem::ConstDef(it) => {
                let def = ConstLoc {
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index e11bdf3ec..a0cdad529 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -374,7 +374,7 @@ pub struct RecordFieldPat {
 pub enum Pat {
    Missing,
    Wild,
-    Tuple(Vec<PatId>),
+    Tuple { args: Vec<PatId>, ellipsis: Option<usize> },
    Or(Vec<PatId>),
    Record { path: Option<Path>, args: Vec<RecordFieldPat>, ellipsis: bool },
    Range { start: ExprId, end: ExprId },
@@ -382,7 +382,7 @@ pub enum Pat {
    Path(Path),
    Lit(ExprId),
    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
-    TupleStruct { path: Option<Path>, args: Vec<PatId> },
+    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
    Ref { pat: PatId, mutability: Mutability },
 }
@@ -393,7 +393,7 @@ impl Pat {
            Pat::Bind { subpat, .. } => {
                subpat.iter().copied().for_each(f);
            }
-            Pat::Or(args) | Pat::Tuple(args) | Pat::TupleStruct { args, .. } => {
+            Pat::Or(args) | Pat::Tuple { args, .. } | Pat::TupleStruct { args, .. } => {
                args.iter().copied().for_each(f);
            }
            Pat::Ref { pat, .. } => f(*pat),
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 8fe3f8617..98c74fe25 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -462,6 +462,14 @@ impl DefCollector<'_> {
                Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => {
                    tested_by!(glob_enum);
                    // glob import from enum => just import all the variants
+                    // XXX: urgh, so this works by accident! Here, we look at
+                    // the enum data, and, in theory, this might require us to
+                    // look back at the crate_def_map, creating a cycle. For
+                    // example, `enum E { crate::some_macro!(); }`. Luckely, the
+                    // only kind of macro that is allowed inside enum is a
+                    // `cfg_macro`, and we don't need to run name resolution for
+                    // it, but this is sheer luck!
                    let enum_data = self.db.enum_data(e);
                    let resolutions = enum_data
                        .variants
@@ -977,11 +985,7 @@ impl ModCollector<'_, '_> {
    }
    fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
-        // FIXME: handle cfg_attr :-)
+        attrs.is_cfg_enabled(self.def_collector.cfg_options)
-        attrs
-            .by_key("cfg")
-            .tt_values()
-            .all(|tt| self.def_collector.cfg_options.is_cfg_enabled(tt) != Some(false))
    }
 }
diff --git a/crates/ra_hir_def/src/nameres/tests/incremental.rs b/crates/ra_hir_def/src/nameres/tests/incremental.rs
index 496fc6b08..87165ac33 100644
--- a/crates/ra_hir_def/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir_def/src/nameres/tests/incremental.rs
@@ -32,6 +32,9 @@ fn typing_inside_a_function_should_not_invalidate_def_map() {
        use crate::foo::bar::Baz;
+        enum E { A, B }
+        use E::*;
        fn foo() -> i32 {
            1 + 1
        }
@@ -46,6 +49,9 @@ fn typing_inside_a_function_should_not_invalidate_def_map() {
        use crate::foo::bar::Baz;
+        enum E { A, B }
+        use E::*;
        fn foo() -> i32 { 92 }
        ",
    );
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 904080341..162b3c8c7 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -14,7 +14,10 @@ use hir_expand::{
 use ra_db::CrateId;
 use ra_syntax::ast;
-use crate::{type_ref::TypeRef, InFile};
+use crate::{
+    type_ref::{TypeBound, TypeRef},
+    InFile,
+};
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ModPath {
@@ -111,7 +114,21 @@ pub struct GenericArgs {
    /// is left out.
    pub has_self_type: bool,
    /// Associated type bindings like in `Iterator<Item = T>`.
-    pub bindings: Vec<(Name, TypeRef)>,
+    pub bindings: Vec<AssociatedTypeBinding>,
+}
+/// An associated type binding like in `Iterator<Item = T>`.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AssociatedTypeBinding {
+    /// The name of the associated type.
+    pub name: Name,
+    /// The type bound to this associated type (in `Item = T`, this would be the
+    /// `T`). This can be `None` if there are bounds instead.
+    pub type_ref: Option<TypeRef>,
+    /// Bounds for the associated type, like in `Iterator<Item:
+    /// SomeOtherTrait>`. (This is the unstable `associated_type_bounds`
+    /// feature.)
+    pub bounds: Vec<TypeBound>,
 }
 /// A single generic argument.
@@ -134,11 +151,6 @@ impl Path {
        lower::lower_path(path, hygiene)
    }
-    /// Converts an `ast::NameRef` into a single-identifier `Path`.
-    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> Path {
-        Path { type_anchor: None, mod_path: name_ref.as_name().into(), generic_args: vec![None] }
-    }
    /// Converts a known mod path to `Path`.
    pub(crate) fn from_known_path(
        path: ModPath,
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index 0f806d6fb..9ec2e0dcd 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -9,11 +9,12 @@ use hir_expand::{
    hygiene::Hygiene,
    name::{name, AsName},
 };
-use ra_syntax::ast::{self, AstNode, TypeAscriptionOwner};
+use ra_syntax::ast::{self, AstNode, TypeAscriptionOwner, TypeBoundsOwner};
+use super::AssociatedTypeBinding;
 use crate::{
    path::{GenericArg, GenericArgs, ModPath, Path, PathKind},
-    type_ref::TypeRef,
+    type_ref::{TypeBound, TypeRef},
 };
 pub(super) use lower_use::lower_use_tree;
@@ -136,10 +137,16 @@ pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs>
    // lifetimes ignored for now
    let mut bindings = Vec::new();
    for assoc_type_arg in node.assoc_type_args() {
+        let assoc_type_arg: ast::AssocTypeArg = assoc_type_arg;
        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());
+            let type_ref = assoc_type_arg.type_ref().map(TypeRef::from_ast);
-            bindings.push((name, type_ref));
+            let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
+                l.bounds().map(TypeBound::from_ast).collect()
+            } else {
+                Vec::new()
+            };
+            bindings.push(AssociatedTypeBinding { name, type_ref, bounds });
        }
    }
    if args.is_empty() && bindings.is_empty() {
@@ -168,7 +175,11 @@ fn lower_generic_args_from_fn_path(
    }
    if let Some(ret_type) = ret_type {
        let type_ref = TypeRef::from_ast_opt(ret_type.type_ref());
-        bindings.push((name![Output], type_ref))
+        bindings.push(AssociatedTypeBinding {
+            name: name![Output],
+            type_ref: Some(type_ref),
+            bounds: Vec::new(),
+        });
    }
    if args.is_empty() && bindings.is_empty() {
        None
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index ea29c4176..f308c6bdf 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -163,8 +163,16 @@ impl TypeRef {
                        let crate::path::GenericArg::Type(type_ref) = arg;
                        go(type_ref, f);
                    }
-                    for (_, type_ref) in &args_and_bindings.bindings {
+                    for binding in &args_and_bindings.bindings {
-                        go(type_ref, f);
+                        if let Some(type_ref) = &binding.type_ref {
+                            go(type_ref, f);
+                        }
+                        for bound in &binding.bounds {
+                            match bound {
+                                TypeBound::Path(path) => go_path(path, f),
+                                TypeBound::Error => (),
+                            }
+                        }
                    }
                }
            }
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 25cc1e9fc..fecce224e 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -83,6 +83,15 @@ impl AsName for ast::Name {
    }
 }
+impl AsName for ast::NameOrNameRef {
+    fn as_name(&self) -> Name {
+        match self {
+            ast::NameOrNameRef::Name(it) => it.as_name(),
+            ast::NameOrNameRef::NameRef(it) => it.as_name(),
+        }
+    }
+}
 impl AsName for tt::Ident {
    fn as_name(&self) -> Name {
        Name::resolve(&self.text)
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 59efc1c31..e891d733f 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -8,6 +8,7 @@ authors = ["rust-analyzer developers"]
 doctest = false
 [dependencies]
+itertools = "0.9.0"
 arrayvec = "0.5.1"
 smallvec = "1.2.0"
 ena = "0.13.1"
@@ -26,9 +27,9 @@ test_utils = { path = "../test_utils" }
 scoped-tls = "1"
-chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "039fc904a05f8cb3d0c682c9a57a63dda7a35356" }
+chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "6222e416b96892b2a86bc08de7dbc9826ff1acea" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "039fc904a05f8cb3d0c682c9a57a63dda7a35356" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "6222e416b96892b2a86bc08de7dbc9826ff1acea" }
-chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "039fc904a05f8cb3d0c682c9a57a63dda7a35356" }
+chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "6222e416b96892b2a86bc08de7dbc9826ff1acea" }
 [dev-dependencies]
-insta = "0.15.0"
+insta = "0.16.0"
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 9e9a9d047..a64be9848 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -289,7 +289,7 @@ impl PatStack {
        Self::from_slice(&self.0[1..])
    }
-    fn replace_head_with(&self, pat_ids: &[PatId]) -> PatStack {
+    fn replace_head_with<T: Into<PatIdOrWild> + Copy>(&self, pat_ids: &[T]) -> PatStack {
        let mut patterns: PatStackInner = smallvec![];
        for pat in pat_ids {
            patterns.push((*pat).into());
@@ -320,12 +320,14 @@ impl PatStack {
        constructor: &Constructor,
    ) -> MatchCheckResult<Option<PatStack>> {
        let result = match (self.head().as_pat(cx), constructor) {
-            (Pat::Tuple(ref pat_ids), Constructor::Tuple { arity }) => {
+            (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
-                debug_assert_eq!(
+                if ellipsis.is_some() {
-                    pat_ids.len(),
+                    // If there are ellipsis here, we should add the correct number of
-                    *arity,
+                    // Pat::Wild patterns to `pat_ids`. We should be able to use the
-                    "we type check before calling this code, so we should never hit this case",
+                    // constructors arity for this, but at the time of writing we aren't
-                );
+                    // correctly calculating this arity when ellipsis are present.
+                    return Err(MatchCheckErr::NotImplemented);
+                }
                Some(self.replace_head_with(pat_ids))
            }
@@ -351,19 +353,47 @@ impl PatStack {
                    Some(self.to_tail())
                }
            }
-            (Pat::TupleStruct { args: ref pat_ids, .. }, Constructor::Enum(enum_constructor)) => {
+            (
+                Pat::TupleStruct { args: ref pat_ids, ellipsis, .. },
+                Constructor::Enum(enum_constructor),
+            ) => {
                let pat_id = self.head().as_id().expect("we know this isn't a wild");
                if !enum_variant_matches(cx, pat_id, *enum_constructor) {
                    None
                } else {
-                    // If the enum variant matches, then we need to confirm
+                    let constructor_arity = constructor.arity(cx)?;
-                    // that the number of patterns aligns with the expected
+                    if let Some(ellipsis_position) = ellipsis {
-                    // number of patterns for that enum variant.
+                        // If there are ellipsis in the pattern, the ellipsis must take the place
-                    if pat_ids.len() != constructor.arity(cx)? {
+                        // of at least one sub-pattern, so `pat_ids` should be smaller than the
-                        return Err(MatchCheckErr::MalformedMatchArm);
+                        // constructor arity.
+                        if pat_ids.len() < constructor_arity {
+                            let mut new_patterns: Vec<PatIdOrWild> = vec![];
+                            for pat_id in &pat_ids[0..ellipsis_position] {
+                                new_patterns.push((*pat_id).into());
+                            }
+                            for _ in 0..(constructor_arity - pat_ids.len()) {
+                                new_patterns.push(PatIdOrWild::Wild);
+                            }
+                            for pat_id in &pat_ids[ellipsis_position..pat_ids.len()] {
+                                new_patterns.push((*pat_id).into());
+                            }
+                            Some(self.replace_head_with(&new_patterns))
+                        } else {
+                            return Err(MatchCheckErr::MalformedMatchArm);
+                        }
+                    } else {
+                        // If there is no ellipsis in the tuple pattern, the number
+                        // of patterns must equal the constructor arity.
+                        if pat_ids.len() == constructor_arity {
+                            Some(self.replace_head_with(pat_ids))
+                        } else {
+                            return Err(MatchCheckErr::MalformedMatchArm);
+                        }
                    }
-                    Some(self.replace_head_with(pat_ids))
                }
            }
            (Pat::Or(_), _) => return Err(MatchCheckErr::NotImplemented),
@@ -644,7 +674,11 @@ impl Constructor {
 fn pat_constructor(cx: &MatchCheckCtx, pat: PatIdOrWild) -> MatchCheckResult<Option<Constructor>> {
    let res = match pat.as_pat(cx) {
        Pat::Wild => None,
-        Pat::Tuple(pats) => Some(Constructor::Tuple { arity: pats.len() }),
+        // FIXME somehow create the Tuple constructor with the proper arity. If there are
+        // ellipsis, the arity is not equal to the number of patterns.
+        Pat::Tuple { args: pats, ellipsis } if ellipsis.is_none() => {
+            Some(Constructor::Tuple { arity: pats.len() })
+        }
        Pat::Lit(lit_expr) => match cx.body.exprs[lit_expr] {
            Expr::Literal(Literal::Bool(val)) => Some(Constructor::Bool(val)),
            _ => return Err(MatchCheckErr::NotImplemented),
@@ -973,6 +1007,47 @@ mod tests {
    }
    #[test]
+    fn tuple_of_bools_with_ellipsis_at_end_no_diagnostic() {
+        let content = r"
+            fn test_fn() {
+                match (false, true, false) {
+                    (false, ..) => {},
+                    (true, ..) => {},
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
+        let content = r"
+            fn test_fn() {
+                match (false, true, false) {
+                    (.., false) => {},
+                    (.., true) => {},
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_no_diagnostic() {
+        let content = r"
+            fn test_fn() {
+                match (false, true, false) {
+                    (..) => {},
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
    fn tuple_of_tuple_and_bools_no_arms() {
        let content = r"
            fn test_fn() {
@@ -1315,8 +1390,9 @@ mod tests {
            }
        ";
-        // Match arms with the incorrect type are filtered out.
+        // Match statements with arms that don't match the
-        check_diagnostic(content);
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(content);
    }
    #[test]
@@ -1330,8 +1406,9 @@ mod tests {
            }
        ";
-        // Match arms with the incorrect type are filtered out.
+        // Match statements with arms that don't match the
-        check_diagnostic(content);
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(content);
    }
    #[test]
@@ -1344,8 +1421,9 @@ mod tests {
            }
        ";
-        // Match arms with the incorrect type are filtered out.
+        // Match statements with arms that don't match the
-        check_diagnostic(content);
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(content);
    }
    #[test]
@@ -1383,6 +1461,163 @@ mod tests {
        // we don't create a diagnostic).
        check_no_diagnostic(content);
    }
+    #[test]
+    fn expr_diverges() {
+        let content = r"
+            enum Either {
+                A,
+                B,
+            }
+            fn test_fn() {
+                match loop {} {
+                    Either::A => (),
+                    Either::B => (),
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn expr_loop_with_break() {
+        let content = r"
+            enum Either {
+                A,
+                B,
+            }
+            fn test_fn() {
+                match loop { break Foo::A } {
+                    Either::A => (),
+                    Either::B => (),
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn expr_partially_diverges() {
+        let content = r"
+            enum Either<T> {
+                A(T),
+                B,
+            }
+            fn foo() -> Either<!> {
+                Either::B
+            }
+            fn test_fn() -> u32 {
+                match foo() {
+                    Either::A(val) => val,
+                    Either::B => 0,
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn enum_tuple_partial_ellipsis_no_diagnostic() {
+        let content = r"
+            enum Either {
+                A(bool, bool, bool, bool),
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A(true, .., true) => {},
+                    Either::A(true, .., false) => {},
+                    Either::A(false, .., true) => {},
+                    Either::A(false, .., false) => {},
+                    Either::B => {},
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
+        let content = r"
+            enum Either {
+                A(bool, bool, bool, bool),
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A(true, .., true) => {},
+                    Either::A(true, .., false) => {},
+                    Either::A(.., true) => {},
+                    Either::A(.., false) => {},
+                    Either::B => {},
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn enum_tuple_partial_ellipsis_missing_arm() {
+        let content = r"
+            enum Either {
+                A(bool, bool, bool, bool),
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A(true, .., true) => {},
+                    Either::A(true, .., false) => {},
+                    Either::A(false, .., false) => {},
+                    Either::B => {},
+                }
+            }
+        ";
+        check_diagnostic(content);
+    }
+    #[test]
+    fn enum_tuple_partial_ellipsis_2_missing_arm() {
+        let content = r"
+            enum Either {
+                A(bool, bool, bool, bool),
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A(true, .., true) => {},
+                    Either::A(true, .., false) => {},
+                    Either::A(.., true) => {},
+                    Either::B => {},
+                }
+            }
+        ";
+        check_diagnostic(content);
+    }
+    #[test]
+    fn enum_tuple_ellipsis_no_diagnostic() {
+        let content = r"
+            enum Either {
+                A(bool, bool, bool, bool),
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A(..) => {},
+                    Either::B => {},
+                }
+            }
+        ";
+        check_no_diagnostic(content);
+    }
 }
 #[cfg(test)]
@@ -1452,4 +1687,75 @@ mod false_negatives {
        // We do not currently handle patterns with internal `or`s.
        check_no_diagnostic(content);
    }
+    #[test]
+    fn expr_diverges_missing_arm() {
+        let content = r"
+            enum Either {
+                A,
+                B,
+            }
+            fn test_fn() {
+                match loop {} {
+                    Either::A => (),
+                }
+            }
+        ";
+        // This is a false negative.
+        // Even though the match expression diverges, rustc fails
+        // to compile here since `Either::B` is missing.
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn expr_loop_missing_arm() {
+        let content = r"
+            enum Either {
+                A,
+                B,
+            }
+            fn test_fn() {
+                match loop { break Foo::A } {
+                    Either::A => (),
+                }
+            }
+        ";
+        // This is a false negative.
+        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+        // causes us to skip the diagnostic since `Either::A` doesn't type check
+        // with `!`.
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+        let content = r"
+            fn test_fn() {
+                match (false, true, false) {
+                    (false, ..) => {},
+                }
+            }
+        ";
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(content);
+    }
+    #[test]
+    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+        let content = r"
+            fn test_fn() {
+                match (false, true, false) {
+                    (.., false) => {},
+                }
+            }
+        ";
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(content);
+    }
 }
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index 1462b053f..33da16b48 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -11,7 +11,7 @@ use ra_db::{impl_intern_key, salsa, CrateId, Upcast};
 use ra_prof::profile;
 use crate::{
-    method_resolution::CrateImplDefs,
+    method_resolution::{CrateImplDefs, TyFingerprint},
    traits::{chalk, AssocTyValue, Impl},
    Binders, CallableDef, GenericPredicate, InferenceResult, PolyFnSig, Substs, TraitRef, Ty,
    TyDefId, TypeCtor, ValueTyDefId,
@@ -65,7 +65,12 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplDefs>;
    #[salsa::invoke(crate::traits::impls_for_trait_query)]
-    fn impls_for_trait(&self, krate: CrateId, trait_: TraitId) -> Arc<[ImplId]>;
+    fn impls_for_trait(
+        &self,
+        krate: CrateId,
+        trait_: TraitId,
+        self_ty_fp: Option<TyFingerprint>,
+    ) -> Arc<[ImplId]>;
    // Interned IDs for Chalk integration
    #[salsa::interned]
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs
index 827b687de..21abbcf1e 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/expr.rs
@@ -89,21 +89,19 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        let (_, source_map) = db.body_with_source_map(self.func.into());
        if let Ok(source_ptr) = source_map.expr_syntax(id) {
-            if let Some(expr) = source_ptr.value.as_ref().left() {
+            let root = source_ptr.file_syntax(db.upcast());
-                let root = source_ptr.file_syntax(db.upcast());
+            if let ast::Expr::RecordLit(record_lit) = &source_ptr.value.to_node(&root) {
-                if let ast::Expr::RecordLit(record_lit) = expr.to_node(&root) {
+                if let Some(field_list) = record_lit.record_field_list() {
-                    if let Some(field_list) = record_lit.record_field_list() {
+                    let variant_data = variant_data(db.upcast(), variant_def);
-                        let variant_data = variant_data(db.upcast(), variant_def);
+                    let missed_fields = missed_fields
-                        let missed_fields = missed_fields
+                        .into_iter()
-                            .into_iter()
+                        .map(|idx| variant_data.fields()[idx].name.clone())
-                            .map(|idx| variant_data.fields()[idx].name.clone())
+                        .collect();
-                            .collect();
+                    self.sink.push(MissingFields {
-                        self.sink.push(MissingFields {
+                        file: source_ptr.file_id,
-                            file: source_ptr.file_id,
+                        field_list: AstPtr::new(&field_list),
-                            field_list: AstPtr::new(&field_list),
+                        missed_fields,
-                            missed_fields,
+                    })
-                        })
-                    }
                }
            }
        }
@@ -163,12 +161,6 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        let mut seen = Matrix::empty();
        for pat in pats {
-            // We skip any patterns whose type we cannot resolve.
-            //
-            // This could lead to false positives in this diagnostic, so
-            // it might be better to skip the entire diagnostic if we either
-            // cannot resolve a match arm or determine that the match arm has
-            // the wrong type.
            if let Some(pat_ty) = infer.type_of_pat.get(pat) {
                // We only include patterns whose type matches the type
                // of the match expression. If we had a InvalidMatchArmPattern
@@ -191,8 +183,15 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                    // to the matrix here.
                    let v = PatStack::from_pattern(pat);
                    seen.push(&cx, v);
+                    continue;
                }
            }
+            // If we can't resolve the type of a pattern, or the pattern type doesn't
+            // fit the match expression, we skip this diagnostic. Skipping the entire
+            // diagnostic rather than just not including this match arm is preferred
+            // to avoid the chance of false positives.
+            return;
        }
        match is_useful(&cx, &seen, &PatStack::from_wild()) {
@@ -205,18 +204,16 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        }
        if let Ok(source_ptr) = source_map.expr_syntax(id) {
-            if let Some(expr) = source_ptr.value.as_ref().left() {
+            let root = source_ptr.file_syntax(db.upcast());
-                let root = source_ptr.file_syntax(db.upcast());
+            if let ast::Expr::MatchExpr(match_expr) = &source_ptr.value.to_node(&root) {
-                if let ast::Expr::MatchExpr(match_expr) = expr.to_node(&root) {
+                if let (Some(match_expr), Some(arms)) =
-                    if let (Some(match_expr), Some(arms)) =
+                    (match_expr.expr(), match_expr.match_arm_list())
-                        (match_expr.expr(), match_expr.match_arm_list())
+                {
-                    {
+                    self.sink.push(MissingMatchArms {
-                        self.sink.push(MissingMatchArms {
+                        file: source_ptr.file_id,
-                            file: source_ptr.file_id,
+                        match_expr: AstPtr::new(&match_expr),
-                            match_expr: AstPtr::new(&match_expr),
+                        arms: AstPtr::new(&arms),
-                            arms: AstPtr::new(&arms),
+                    })
-                        })
-                    }
                }
            }
        }
@@ -247,9 +244,8 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            let (_, source_map) = db.body_with_source_map(self.func.into());
            if let Ok(source_ptr) = source_map.expr_syntax(id) {
-                if let Some(expr) = source_ptr.value.left() {
+                self.sink
-                    self.sink.push(MissingOkInTailExpr { file: source_ptr.file_id, expr });
+                    .push(MissingOkInTailExpr { file: source_ptr.file_id, expr: source_ptr.value });
-                }
            }
        }
    }
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index 078476f76..8ec4d4ace 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -85,7 +85,7 @@ impl<'a> InferenceContext<'a> {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
        let is_non_ref_pat = match &body[pat] {
-            Pat::Tuple(..)
+            Pat::Tuple { .. }
            | Pat::Or(..)
            | Pat::TupleStruct { .. }
            | Pat::Record { .. }
@@ -116,7 +116,7 @@ impl<'a> InferenceContext<'a> {
        let expected = expected;
        let ty = match &body[pat] {
-            Pat::Tuple(ref args) => {
+            Pat::Tuple { ref args, .. } => {
                let expectations = match expected.as_tuple() {
                    Some(parameters) => &*parameters.0,
                    _ => &[],
@@ -155,7 +155,7 @@ impl<'a> InferenceContext<'a> {
                let subty = self.infer_pat(*pat, expectation, default_bm);
                Ty::apply_one(TypeCtor::Ref(*mutability), subty)
            }
-            Pat::TupleStruct { path: p, args: subpats } => {
+            Pat::TupleStruct { path: p, args: subpats, .. } => {
                self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm, pat)
            }
            Pat::Record { path: p, args: fields, ellipsis: _ } => {
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 6c7bbc448..cc1ac8e3e 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -8,6 +8,8 @@
 use std::iter;
 use std::sync::Arc;
+use smallvec::SmallVec;
 use hir_def::{
    adt::StructKind,
    builtin_type::BuiltinType,
@@ -360,13 +362,23 @@ impl Ty {
            },
            Some(TypeNs::GenericParam(param_id)) => {
                let predicates = ctx.db.generic_predicates_for_param(param_id);
-                predicates
+                let mut traits_: Vec<_> = predicates
                    .iter()
                    .filter_map(|pred| match &pred.value {
                        GenericPredicate::Implemented(tr) => Some(tr.trait_),
                        _ => None,
                    })
-                    .collect()
+                    .collect();
+                // Handle `Self::Type` referring to own associated type in trait definitions
+                if let GenericDefId::TraitId(trait_id) = param_id.parent {
+                    let generics = generics(ctx.db.upcast(), trait_id.into());
+                    if generics.params.types[param_id.local_id].provenance
+                        == TypeParamProvenance::TraitSelf
+                    {
+                        traits_.push(trait_id);
+                    }
+                }
+                traits_
            }
            _ => return Ty::Unknown,
        };
@@ -596,21 +608,35 @@ fn assoc_type_bindings_from_type_bound<'a>(
        .into_iter()
        .flat_map(|segment| segment.args_and_bindings.into_iter())
        .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
-        .map(move |(name, type_ref)| {
+        .flat_map(move |binding| {
            let associated_ty = associated_type_by_name_including_super_traits(
                ctx.db.upcast(),
                trait_ref.trait_,
-                &name,
+                &binding.name,
            );
            let associated_ty = match associated_ty {
-                None => return GenericPredicate::Error,
+                None => return SmallVec::<[GenericPredicate; 1]>::new(),
                Some(t) => t,
            };
            let projection_ty =
                ProjectionTy { associated_ty, parameters: trait_ref.substs.clone() };
-            let ty = Ty::from_hir(ctx, type_ref);
+            let mut preds = SmallVec::with_capacity(
-            let projection_predicate = ProjectionPredicate { projection_ty, ty };
+                binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
-            GenericPredicate::Projection(projection_predicate)
+            );
+            if let Some(type_ref) = &binding.type_ref {
+                let ty = Ty::from_hir(ctx, type_ref);
+                let projection_predicate =
+                    ProjectionPredicate { projection_ty: projection_ty.clone(), ty };
+                preds.push(GenericPredicate::Projection(projection_predicate));
+            }
+            for bound in &binding.bounds {
+                preds.extend(GenericPredicate::from_type_bound(
+                    ctx,
+                    bound,
+                    Ty::Projection(projection_ty.clone()),
+                ));
+            }
+            preds
        })
 }
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 74a0bc7db..657284fd0 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -34,7 +34,7 @@ impl TyFingerprint {
    /// Creates a TyFingerprint for looking up an impl. Only certain types can
    /// have impls: if we have some `struct S`, we can have an `impl S`, but not
    /// `impl &S`. Hence, this will return `None` for reference types and such.
-    fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
+    pub(crate) fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
        match ty {
            Ty::Apply(a_ty) => Some(TyFingerprint::Apply(a_ty.ctor)),
            _ => None,
@@ -45,7 +45,7 @@ impl TyFingerprint {
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplDefs {
    impls: FxHashMap<TyFingerprint, Vec<ImplId>>,
-    impls_by_trait: FxHashMap<TraitId, Vec<ImplId>>,
+    impls_by_trait: FxHashMap<TraitId, FxHashMap<Option<TyFingerprint>, Vec<ImplId>>>,
 }
 impl CrateImplDefs {
@@ -59,7 +59,14 @@ impl CrateImplDefs {
            for impl_id in module_data.scope.impls() {
                match db.impl_trait(impl_id) {
                    Some(tr) => {
-                        res.impls_by_trait.entry(tr.value.trait_).or_default().push(impl_id);
+                        let self_ty = db.impl_self_ty(impl_id);
+                        let self_ty_fp = TyFingerprint::for_impl(&self_ty.value);
+                        res.impls_by_trait
+                            .entry(tr.value.trait_)
+                            .or_default()
+                            .entry(self_ty_fp)
+                            .or_default()
+                            .push(impl_id);
                    }
                    None => {
                        let self_ty = db.impl_self_ty(impl_id);
@@ -79,11 +86,39 @@ impl CrateImplDefs {
    }
    pub fn lookup_impl_defs_for_trait(&self, tr: TraitId) -> impl Iterator<Item = ImplId> + '_ {
-        self.impls_by_trait.get(&tr).into_iter().flatten().copied()
+        self.impls_by_trait
+            .get(&tr)
+            .into_iter()
+            .flat_map(|m| m.values().flat_map(|v| v.iter().copied()))
+    }
+    pub fn lookup_impl_defs_for_trait_and_ty(
+        &self,
+        tr: TraitId,
+        fp: TyFingerprint,
+    ) -> impl Iterator<Item = ImplId> + '_ {
+        self.impls_by_trait
+            .get(&tr)
+            .and_then(|m| m.get(&Some(fp)))
+            .into_iter()
+            .flatten()
+            .copied()
+            .chain(
+                self.impls_by_trait
+                    .get(&tr)
+                    .and_then(|m| m.get(&None))
+                    .into_iter()
+                    .flatten()
+                    .copied(),
+            )
    }
    pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplId> + 'a {
-        self.impls.values().chain(self.impls_by_trait.values()).flatten().copied()
+        self.impls
+            .values()
+            .chain(self.impls_by_trait.values().flat_map(|m| m.values()))
+            .flatten()
+            .copied()
    }
 }
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 54e31602f..81fc0f63a 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -82,9 +82,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
        for (expr, ty) in inference_result.type_of_expr.iter() {
            let syntax_ptr = match body_source_map.expr_syntax(expr) {
-                Ok(sp) => {
+                Ok(sp) => sp.map(|ast| ast.syntax_node_ptr()),
-                    sp.map(|ast| ast.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr()))
-                }
                Err(SyntheticSyntax) => continue,
            };
            types.push((syntax_ptr.clone(), ty));
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index 6e5d2247c..07cbc521a 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -1,7 +1,8 @@
-use super::{infer, infer_with_mismatches};
 use insta::assert_snapshot;
 use test_utils::covers;
+use super::{infer, infer_with_mismatches};
 #[test]
 fn infer_pattern() {
    assert_snapshot!(
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 3402e0cb5..d69115a2f 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -451,8 +451,7 @@ pub mod str {
 "#,
    );
-    // should be Option<char>, but currently not because of Chalk ambiguity problem
+    assert_eq!("(Option<char>, Option<char>)", super::type_at_pos(&db, pos));
-    assert_eq!("(Option<{unknown}>, Option<{unknown}>)", super::type_at_pos(&db, pos));
 }
 #[test]
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 22ae6ca90..b3a2fc439 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1803,7 +1803,7 @@ fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
 }
 #[test]
-fn unselected_projection_on_trait_self() {
+fn unselected_projection_on_impl_self() {
    assert_snapshot!(infer(
        r#"
 //- /main.rs
@@ -1844,6 +1844,30 @@ impl Trait for S2 {
 }
 #[test]
+fn unselected_projection_on_trait_self() {
+    let t = type_at(
+        r#"
+//- /main.rs
+trait Trait {
+    type Item;
+    fn f(&self) -> Self::Item { loop {} }
+}
+struct S;
+impl Trait for S {
+    type Item = u32;
+}
+fn test() {
+    S.f()<|>;
+}
+"#,
+    );
+    assert_eq!(t, "u32");
+}
+#[test]
 fn trait_impl_self_ty() {
    let t = type_at(
        r#"
@@ -1924,6 +1948,53 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 }
 #[test]
+fn inline_assoc_type_bounds_1() {
+    let t = type_at(
+        r#"
+//- /main.rs
+trait Iterator {
+    type Item;
+}
+trait OtherTrait<T> {
+    fn foo(&self) -> T;
+}
+// workaround for Chalk assoc type normalization problems
+pub struct S<T>;
+impl<T: Iterator> Iterator for S<T> {
+    type Item = <T as Iterator>::Item;
+}
+fn test<I: Iterator<Item: OtherTrait<u32>>>() {
+    let x: <S<I> as Iterator>::Item;
+    x.foo()<|>;
+}
+"#,
+    );
+    assert_eq!(t, "u32");
+}
+#[test]
+fn inline_assoc_type_bounds_2() {
+    let t = type_at(
+        r#"
+//- /main.rs
+trait Iterator {
+    type Item;
+}
+fn test<I: Iterator<Item: Iterator<Item = u32>>>() {
+    let x: <<I as Iterator>::Item as Iterator>::Item;
+    x<|>;
+}
+"#,
+    );
+    // assert_eq!(t, "u32");
+    // doesn't currently work, Chalk #234
+    assert_eq!(t, "{unknown}");
+}
+#[test]
 fn unify_impl_trait() {
    assert_snapshot!(
        infer_with_mismatches(r#"
@@ -2023,6 +2094,33 @@ fn main() {
 }
 #[test]
+fn associated_type_bound() {
+    let t = type_at(
+        r#"
+//- /main.rs
+pub trait Trait {
+    type Item: OtherTrait<u32>;
+}
+pub trait OtherTrait<T> {
+    fn foo(&self) -> T;
+}
+// this is just a workaround for chalk#234
+pub struct S<T>;
+impl<T: Trait> Trait for S<T> {
+    type Item = <T as Trait>::Item;
+}
+fn test<T: Trait>() {
+    let y: <S<T> as Trait>::Item = no_matter;
+    y.foo()<|>;
+}
+"#,
+    );
+    assert_eq!(t, "u32");
+}
+#[test]
 fn dyn_trait_through_chalk() {
    let t = type_at(
        r#"
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 21e233379..44fbdb197 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -7,7 +7,7 @@ use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
 use rustc_hash::FxHashSet;
-use crate::{db::HirDatabase, DebruijnIndex};
+use crate::{db::HirDatabase, method_resolution::TyFingerprint, DebruijnIndex};
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
@@ -40,7 +40,12 @@ pub(crate) fn impls_for_trait_query(
    db: &dyn HirDatabase,
    krate: CrateId,
    trait_: TraitId,
+    self_ty_fp: Option<TyFingerprint>,
 ) -> Arc<[ImplId]> {
+    // FIXME: We could be a lot smarter here - because of the orphan rules and
+    // the fact that the trait and the self type need to be in the dependency
+    // tree of a crate somewhere for an impl to exist, we could skip looking in
+    // a lot of crates completely
    let mut impls = FxHashSet::default();
    // We call the query recursively here. On the one hand, this means we can
    // reuse results from queries for different crates; on the other hand, this
@@ -48,10 +53,13 @@ pub(crate) fn impls_for_trait_query(
    // ones the user is editing), so this may actually be a waste of memory. I'm
    // doing it like this mainly for simplicity for now.
    for dep in &db.crate_graph()[krate].dependencies {
-        impls.extend(db.impls_for_trait(dep.crate_id, trait_).iter());
+        impls.extend(db.impls_for_trait(dep.crate_id, trait_, self_ty_fp).iter());
    }
    let crate_impl_defs = db.impls_in_crate(krate);
-    impls.extend(crate_impl_defs.lookup_impl_defs_for_trait(trait_));
+    match self_ty_fp {
+        Some(fp) => impls.extend(crate_impl_defs.lookup_impl_defs_for_trait_and_ty(trait_, fp)),
+        None => impls.extend(crate_impl_defs.lookup_impl_defs_for_trait(trait_)),
+    }
    impls.into_iter().collect()
 }
@@ -186,13 +194,16 @@ fn solve(
        }
        remaining > 0
    };
-    let mut solve = || solver.solve_limited(&context, goal, should_continue);
+    let mut solve = || {
+        let solution = solver.solve_limited(&context, goal, should_continue);
+        log::debug!("solve({:?}) => {:?}", goal, solution);
+        solution
+    };
    // don't set the TLS for Chalk unless Chalk debugging is active, to make
    // extra sure we only use it for debugging
    let solution =
        if is_chalk_debug() { chalk::tls::set_current_program(db, solve) } else { solve() };
-    log::debug!("solve({:?}) => {:?}", goal, solution);
    solution
 }
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index c5f1b5232..55eb0ffcb 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -16,8 +16,8 @@ use ra_db::{
 use super::{builtin, AssocTyValue, Canonical, ChalkContext, Impl, Obligation};
 use crate::{
-    db::HirDatabase, display::HirDisplay, utils::generics, ApplicationTy, GenericPredicate,
+    db::HirDatabase, display::HirDisplay, method_resolution::TyFingerprint, utils::generics,
-    ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    ApplicationTy, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
 pub(super) mod tls;
@@ -32,6 +32,9 @@ impl chalk_ir::interner::Interner for Interner {
    type InternedGoal = Arc<GoalData<Self>>;
    type InternedGoals = Vec<Goal<Self>>;
    type InternedSubstitution = Vec<Parameter<Self>>;
+    type InternedProgramClause = chalk_ir::ProgramClauseData<Self>;
+    type InternedProgramClauses = Vec<chalk_ir::ProgramClause<Self>>;
+    type InternedQuantifiedWhereClauses = Vec<chalk_ir::QuantifiedWhereClause<Self>>;
    type Identifier = TypeAliasId;
    type DefId = InternId;
@@ -181,6 +184,48 @@ impl chalk_ir::interner::Interner for Interner {
    ) -> &'a [Parameter<Self>] {
        substitution
    }
+    fn intern_program_clause(
+        &self,
+        data: chalk_ir::ProgramClauseData<Self>,
+    ) -> chalk_ir::ProgramClauseData<Self> {
+        data
+    }
+    fn program_clause_data<'a>(
+        &self,
+        clause: &'a chalk_ir::ProgramClauseData<Self>,
+    ) -> &'a chalk_ir::ProgramClauseData<Self> {
+        clause
+    }
+    fn intern_program_clauses(
+        &self,
+        data: impl IntoIterator<Item = chalk_ir::ProgramClause<Self>>,
+    ) -> Vec<chalk_ir::ProgramClause<Self>> {
+        data.into_iter().collect()
+    }
+    fn program_clauses_data<'a>(
+        &self,
+        clauses: &'a Vec<chalk_ir::ProgramClause<Self>>,
+    ) -> &'a [chalk_ir::ProgramClause<Self>] {
+        clauses
+    }
+    fn intern_quantified_where_clauses(
+        &self,
+        data: impl IntoIterator<Item = chalk_ir::QuantifiedWhereClause<Self>>,
+    ) -> Self::InternedQuantifiedWhereClauses {
+        data.into_iter().collect()
+    }
+    fn quantified_where_clauses_data<'a>(
+        &self,
+        clauses: &'a Self::InternedQuantifiedWhereClauses,
+    ) -> &'a [chalk_ir::QuantifiedWhereClause<Self>] {
+        clauses
+    }
 }
 impl chalk_ir::interner::HasInterner for Interner {
@@ -238,12 +283,10 @@ impl ToChalk for Ty {
            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx).intern(&Interner),
            Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
            Ty::Dyn(predicates) => {
-                let where_clauses = predicates
+                let where_clauses = chalk_ir::QuantifiedWhereClauses::from(
-                    .iter()
+                    &Interner,
-                    .filter(|p| !p.is_error())
+                    predicates.iter().filter(|p| !p.is_error()).cloned().map(|p| p.to_chalk(db)),
-                    .cloned()
+                );
-                    .map(|p| p.to_chalk(db))
-                    .collect();
                let bounded_ty = chalk_ir::DynTy { bounds: make_binders(where_clauses, 1) };
                chalk_ir::TyData::Dyn(bounded_ty).intern(&Interner)
            }
@@ -281,8 +324,12 @@ impl ToChalk for Ty {
            chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
            chalk_ir::TyData::Dyn(where_clauses) => {
                assert_eq!(where_clauses.bounds.binders.len(), 1);
-                let predicates =
+                let predicates = where_clauses
-                    where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
+                    .bounds
+                    .skip_binders()
+                    .iter(&Interner)
+                    .map(|c| from_chalk(db, c.clone()))
+                    .collect();
                Ty::Dyn(predicates)
            }
        }
@@ -426,7 +473,7 @@ impl ToChalk for GenericPredicate {
    ) -> GenericPredicate {
        // we don't produce any where clauses with binders and can't currently deal with them
        match where_clause
-            .value
+            .skip_binders()
            .shifted_out(&Interner)
            .expect("unexpected bound vars in where clause")
        {
@@ -521,7 +568,7 @@ impl ToChalk for Arc<super::TraitEnvironment> {
                pred.clone().to_chalk(db).cast(&Interner);
            clauses.push(program_clause.into_from_env_clause(&Interner));
        }
-        chalk_ir::Environment::new().add_clauses(clauses)
+        chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses)
    }
    fn from_chalk(
@@ -603,10 +650,10 @@ impl ToChalk for builtin::BuiltinImplAssocTyValueData {
 }
 fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T> {
-    chalk_ir::Binders {
+    chalk_ir::Binders::new(
+        std::iter::repeat(chalk_ir::ParameterKind::Ty(())).take(num_vars).collect(),
        value,
-        binders: std::iter::repeat(chalk_ir::ParameterKind::Ty(())).take(num_vars).collect(),
+    )
-    }
 }
 fn convert_where_clauses(
@@ -626,6 +673,55 @@ fn convert_where_clauses(
    result
 }
+fn generic_predicate_to_inline_bound(
+    db: &dyn HirDatabase,
+    pred: &GenericPredicate,
+    self_ty: &Ty,
+) -> Option<chalk_rust_ir::InlineBound<Interner>> {
+    // An InlineBound is like a GenericPredicate, except the self type is left out.
+    // We don't have a special type for this, but Chalk does.
+    match pred {
+        GenericPredicate::Implemented(trait_ref) => {
+            if &trait_ref.substs[0] != self_ty {
+                // we can only convert predicates back to type bounds if they
+                // have the expected self type
+                return None;
+            }
+            let args_no_self = trait_ref.substs[1..]
+                .iter()
+                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
+                .collect();
+            let trait_bound =
+                chalk_rust_ir::TraitBound { trait_id: trait_ref.trait_.to_chalk(db), args_no_self };
+            Some(chalk_rust_ir::InlineBound::TraitBound(trait_bound))
+        }
+        GenericPredicate::Projection(proj) => {
+            if &proj.projection_ty.parameters[0] != self_ty {
+                return None;
+            }
+            let trait_ = match proj.projection_ty.associated_ty.lookup(db.upcast()).container {
+                AssocContainerId::TraitId(t) => t,
+                _ => panic!("associated type not in trait"),
+            };
+            let args_no_self = proj.projection_ty.parameters[1..]
+                .iter()
+                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
+                .collect();
+            let alias_eq_bound = chalk_rust_ir::AliasEqBound {
+                value: proj.ty.clone().to_chalk(db),
+                trait_bound: chalk_rust_ir::TraitBound {
+                    trait_id: trait_.to_chalk(db),
+                    args_no_self,
+                },
+                associated_ty_id: proj.projection_ty.associated_ty.to_chalk(db),
+                parameters: Vec::new(), // FIXME we don't support generic associated types yet
+            };
+            Some(chalk_rust_ir::InlineBound::AliasEqBound(alias_eq_bound))
+        }
+        GenericPredicate::Error => None,
+    }
+}
 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
        self.db.associated_ty_data(id)
@@ -647,19 +743,22 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        debug!("impls_for_trait {:?}", trait_id);
        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
+        let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref(&Interner).clone());
+        let self_ty_fp = TyFingerprint::for_impl(&ty);
        // Note: Since we're using impls_for_trait, only impls where the trait
        // can be resolved should ever reach Chalk. `impl_datum` relies on that
        // and will panic if the trait can't be resolved.
        let mut result: Vec<_> = self
            .db
-            .impls_for_trait(self.krate, trait_)
+            .impls_for_trait(self.krate, trait_, self_ty_fp)
            .iter()
            .copied()
            .map(Impl::ImplDef)
            .map(|impl_| impl_.to_chalk(self.db))
            .collect();
-        let ty: Ty = from_chalk(self.db, parameters[0].assert_ty_ref(&Interner).clone());
        let arg: Option<Ty> =
            parameters.get(1).map(|p| from_chalk(self.db, p.assert_ty_ref(&Interner).clone()));
@@ -693,6 +792,12 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn interner(&self) -> &Interner {
        &Interner
    }
+    fn well_known_trait_id(
+        &self,
+        _well_known_trait: chalk_rust_ir::WellKnownTrait,
+    ) -> chalk_ir::TraitId<Interner> {
+        unimplemented!()
+    }
 }
 pub(crate) fn associated_ty_data_query(
@@ -705,12 +810,25 @@ pub(crate) fn associated_ty_data_query(
        AssocContainerId::TraitId(t) => t,
        _ => panic!("associated type not in trait"),
    };
+    // Lower bounds -- we could/should maybe move this to a separate query in `lower`
+    let type_alias_data = db.type_alias_data(type_alias);
    let generic_params = generics(db.upcast(), type_alias.into());
-    let bound_data = chalk_rust_ir::AssociatedTyDatumBound {
+    let bound_vars = Substs::bound_vars(&generic_params);
-        // FIXME add bounds and where clauses
+    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
-        bounds: vec![],
+    let ctx = crate::TyLoweringContext::new(db, &resolver)
-        where_clauses: vec![],
+        .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
-    };
+    let self_ty = Ty::Bound(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0));
+    let bounds = type_alias_data
+        .bounds
+        .iter()
+        .flat_map(|bound| GenericPredicate::from_type_bound(&ctx, bound, self_ty.clone()))
+        .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
+        .map(|bound| make_binders(bound.shifted_in(&Interner), 0))
+        .collect();
+    let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
+    let bound_data = chalk_rust_ir::AssociatedTyDatumBound { bounds, where_clauses };
    let datum = AssociatedTyDatum {
        trait_id: trait_.to_chalk(db),
        id,
diff --git a/crates/ra_hir_ty/src/traits/chalk/tls.rs b/crates/ra_hir_ty/src/traits/chalk/tls.rs
index d9bbb54a5..fa8e4d1ad 100644
--- a/crates/ra_hir_ty/src/traits/chalk/tls.rs
+++ b/crates/ra_hir_ty/src/traits/chalk/tls.rs
@@ -2,10 +2,11 @@
 use std::fmt;
 use chalk_ir::{AliasTy, Goal, Goals, Lifetime, Parameter, ProgramClauseImplication, TypeName};
+use itertools::Itertools;
 use super::{from_chalk, Interner};
 use crate::{db::HirDatabase, CallableDef, TypeCtor};
-use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
+use hir_def::{AdtId, AssocContainerId, DefWithBodyId, Lookup, TypeAliasId};
 pub use unsafe_tls::{set_current_program, with_current_program};
@@ -69,7 +70,27 @@ impl DebugContext<'_> {
                write!(f, "{}::{}", trait_name, name)?;
            }
            TypeCtor::Closure { def, expr } => {
-                write!(f, "{{closure {:?} in {:?}}}", expr.into_raw(), def)?;
+                write!(f, "{{closure {:?} in ", expr.into_raw())?;
+                match def {
+                    DefWithBodyId::FunctionId(func) => {
+                        write!(f, "fn {}", self.0.function_data(func).name)?
+                    }
+                    DefWithBodyId::StaticId(s) => {
+                        if let Some(name) = self.0.static_data(s).name.as_ref() {
+                            write!(f, "body of static {}", name)?;
+                        } else {
+                            write!(f, "body of unnamed static {:?}", s)?;
+                        }
+                    }
+                    DefWithBodyId::ConstId(c) => {
+                        if let Some(name) = self.0.const_data(c).name.as_ref() {
+                            write!(f, "body of const {}", name)?;
+                        } else {
+                            write!(f, "body of unnamed const {:?}", c)?;
+                        }
+                    }
+                };
+                write!(f, "}}")?;
            }
        }
        Ok(())
@@ -113,14 +134,15 @@ impl DebugContext<'_> {
        };
        let trait_data = self.0.trait_data(trait_);
        let params = alias.substitution.parameters(&Interner);
-        write!(
+        write!(fmt, "<{:?} as {}", &params[0], trait_data.name,)?;
-            fmt,
+        if params.len() > 1 {
-            "<{:?} as {}<{:?}>>::{}",
+            write!(
-            &params[0],
+                fmt,
-            trait_data.name,
+                "<{}>",
-            &params[1..],
+                &params[1..].iter().format_with(", ", |x, f| f(&format_args!("{:?}", x))),
-            type_alias_data.name
+            )?;
-        )
+        }
+        write!(fmt, ">::{}", type_alias_data.name)
    }
    pub fn debug_ty(
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index b4a29b81b..05c940605 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -35,4 +35,4 @@ ra_assists = { path = "../ra_assists" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 [dev-dependencies]
-insta = "0.15.0"
+insta = "0.16.0"
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index ca57eceff..f95b6baf3 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -208,9 +208,20 @@ mod tests {
        }
    }
-    fn call_info(text: &str) -> CallInfo {
+    fn call_info_helper(text: &str) -> Option<CallInfo> {
        let (analysis, position) = single_file_with_position(text);
-        analysis.call_info(position).unwrap().unwrap()
+        analysis.call_info(position).unwrap()
+    }
+    fn call_info(text: &str) -> CallInfo {
+        let info = call_info_helper(text);
+        assert!(info.is_some());
+        info.unwrap()
+    }
+    fn no_call_info(text: &str) {
+        let info = call_info_helper(text);
+        assert!(info.is_none());
    }
    #[test]
@@ -558,9 +569,8 @@ fn main() {
    }
    #[test]
-    #[should_panic]
    fn cant_call_named_structs() {
-        let _ = call_info(
+        no_call_info(
            r#"
 struct TS { x: u32, y: i32 }
 fn main() {
@@ -594,9 +604,8 @@ fn main() {
    }
    #[test]
-    #[should_panic]
    fn cant_call_enum_records() {
-        let _ = call_info(
+        no_call_info(
            r#"
 enum E {
    /// A Variant
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index 1b7d3122f..a8b4ce114 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -7,6 +7,10 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    if !ctx.is_pat_binding_or_const {
        return;
    }
+    if ctx.record_pat_syntax.is_some() {
+        return;
+    }
    // FIXME: ideally, we should look at the type we are matching against and
    // suggest variants + auto-imports
    ctx.scope().process_all_names(&mut |name, res| {
diff --git a/crates/ra_ide/src/completion/complete_record.rs b/crates/ra_ide/src/completion/complete_record.rs
index f46bcee5c..83a553155 100644
--- a/crates/ra_ide/src/completion/complete_record.rs
+++ b/crates/ra_ide/src/completion/complete_record.rs
@@ -2,7 +2,7 @@
 use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let missing_fields = match (ctx.record_lit_pat.as_ref(), ctx.record_lit_syntax.as_ref()) {
+    let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
        (None, None) => return None,
        (Some(_), Some(_)) => unreachable!("A record cannot be both a literal and a pattern"),
        (Some(record_pat), _) => ctx.sema.record_pattern_missing_fields(record_pat),
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index efde9bf73..2d8e0776c 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -3,7 +3,14 @@
 use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path && !ctx.is_pat_binding_or_const) {
+    if !ctx.is_trivial_path {
+        return;
+    }
+    if ctx.is_pat_binding_or_const
+        || ctx.record_lit_syntax.is_some()
+        || ctx.record_pat_syntax.is_some()
+    {
        return;
    }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 6637afaf7..8b3401595 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -30,7 +30,7 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) function_syntax: Option<ast::FnDef>,
    pub(super) use_item_syntax: Option<ast::UseItem>,
    pub(super) record_lit_syntax: Option<ast::RecordLit>,
-    pub(super) record_lit_pat: Option<ast::RecordPat>,
+    pub(super) record_pat_syntax: Option<ast::RecordPat>,
    pub(super) impl_def: Option<ast::ImplDef>,
    pub(super) is_param: bool,
    /// If a name-binding or reference to a const in a pattern.
@@ -93,7 +93,7 @@ impl<'a> CompletionContext<'a> {
            function_syntax: None,
            use_item_syntax: None,
            record_lit_syntax: None,
-            record_lit_pat: None,
+            record_pat_syntax: None,
            impl_def: None,
            is_param: false,
            is_pat_binding_or_const: false,
@@ -182,6 +182,11 @@ impl<'a> CompletionContext<'a> {
                self.is_param = true;
                return;
            }
+            // FIXME: remove this (V) duplication and make the check more precise
+            if name_ref.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() {
+                self.record_pat_syntax =
+                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
+            }
            self.classify_name_ref(original_file, name_ref, offset);
        }
@@ -211,8 +216,9 @@ impl<'a> CompletionContext<'a> {
                self.is_param = true;
                return;
            }
+            // FIXME: remove this (^) duplication and make the check more precise
            if name.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() {
-                self.record_lit_pat =
+                self.record_pat_syntax =
                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
            }
        }
@@ -227,7 +233,7 @@ impl<'a> CompletionContext<'a> {
        self.name_ref_syntax =
            find_node_at_offset(&original_file, name_ref.syntax().text_range().start());
        let name_range = name_ref.syntax().text_range();
-        if name_ref.syntax().parent().and_then(ast::RecordField::cast).is_some() {
+        if ast::RecordField::for_field_name(&name_ref).is_some() {
            self.record_lit_syntax =
                self.sema.find_node_at_offset_with_macros(&original_file, offset);
        }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index da9f55a69..45b9f7802 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -235,7 +235,10 @@ fn should_show_param_hint(
    param_name: &str,
    argument: &ast::Expr,
 ) -> bool {
-    if param_name.is_empty() || is_argument_similar_to_param(argument, param_name) {
+    if param_name.is_empty()
+        || is_argument_similar_to_param(argument, param_name)
+        || Some(param_name) == fn_signature.name.as_ref().map(String::as_str)
+    {
        return false;
    }
@@ -247,10 +250,7 @@ fn should_show_param_hint(
    // avoid displaying hints for common functions like map, filter, etc.
    // or other obvious words used in std
-    if parameters_len == 1 && is_obvious_param(param_name) {
+    parameters_len != 1 || !is_obvious_param(param_name)
-        return false;
-    }
-    true
 }
 fn is_argument_similar_to_param(argument: &ast::Expr, param_name: &str) -> bool {
@@ -1086,6 +1086,8 @@ impl Test {
    }
    fn no_hints_expected(&self, _: i32, test_var: i32) {}
+    fn frob(&self, frob: bool) {}
 }
 struct Param {}
@@ -1093,6 +1095,8 @@ struct Param {}
 fn different_order(param: &Param) {}
 fn different_order_mut(param: &mut Param) {}
+fn twiddle(twiddle: bool) {}
 fn main() {
    let container: TestVarContainer = TestVarContainer { test_var: 42 };
    let test: Test = Test {};
@@ -1105,6 +1109,9 @@ fn main() {
    let test_var: i32 = 55;
    test_processed.no_hints_expected(22, test_var);
    test_processed.no_hints_expected(33, container.test_var);
+    test_processed.frob(false);
+    twiddle(true);
    let param_begin: Param = Param {};
    different_order(&param_begin);
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index e9934844e..49a8c74fb 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -216,7 +216,7 @@ pub fn classify_name_ref(
        }
    }
-    if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
+    if let Some(record_field) = ast::RecordField::for_field_name(name_ref) {
        tested_by!(goto_def_for_record_fields; force);
        tested_by!(goto_def_for_field_init_shorthand; force);
        if let Some((field, local)) = sema.resolve_record_field(&record_field) {
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index d0530955e..c2a6e82e9 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -282,13 +282,10 @@ fn name_ref(p: &mut Parser) {
 }
 fn name_ref_or_index(p: &mut Parser) {
-    if p.at(IDENT) || p.at(INT_NUMBER) {
+    assert!(p.at(IDENT) || p.at(INT_NUMBER));
-        let m = p.start();
+    let m = p.start();
-        p.bump_any();
+    p.bump_any();
-        m.complete(p, NAME_REF);
+    m.complete(p, NAME_REF);
-    } else {
-        p.err_and_bump("expected identifier");
-    }
 }
 fn error_block(p: &mut Parser, message: &str) {
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index a1bd53063..cb30b25a8 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -619,26 +619,39 @@ pub(crate) fn record_field_list(p: &mut Parser) {
    let m = p.start();
    p.bump(T!['{']);
    while !p.at(EOF) && !p.at(T!['}']) {
+        let m = p.start();
+        // test record_literal_field_with_attr
+        // fn main() {
+        //     S { #[cfg(test)] field: 1 }
+        // }
+        attributes::outer_attributes(p);
        match p.current() {
-            // test record_literal_field_with_attr
+            IDENT | INT_NUMBER => {
-            // fn main() {
+                // test_err record_literal_before_ellipsis_recovery
-            //     S { #[cfg(test)] field: 1 }
+                // fn main() {
-            // }
+                //     S { field ..S::default() }
-            IDENT | INT_NUMBER | T![#] => {
+                // }
-                let m = p.start();
+                if p.nth_at(1, T![:]) || p.nth_at(1, T![..]) {
-                attributes::outer_attributes(p);
+                    name_ref_or_index(p);
-                name_ref_or_index(p);
+                    p.expect(T![:]);
-                if p.eat(T![:]) {
-                    expr(p);
                }
+                expr(p);
                m.complete(p, RECORD_FIELD);
            }
            T![.] if p.at(T![..]) => {
+                m.abandon(p);
                p.bump(T![..]);
                expr(p);
            }
-            T!['{'] => error_block(p, "expected a field"),
+            T!['{'] => {
-            _ => p.err_and_bump("expected identifier"),
+                error_block(p, "expected a field");
+                m.abandon(p);
+            }
+            _ => {
+                p.err_and_bump("expected identifier");
+                m.abandon(p);
+            }
        }
        if !p.at(T!['}']) {
            p.expect(T![,]);
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index 936d27575..68fb2fc73 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -192,14 +192,30 @@ fn record_field_pat_list(p: &mut Parser) {
        match p.current() {
            // A trailing `..` is *not* treated as a DOT_DOT_PAT.
            T![.] if p.at(T![..]) => p.bump(T![..]),
-            IDENT | INT_NUMBER if p.nth(1) == T![:] => record_field_pat(p),
            T!['{'] => error_block(p, "expected ident"),
-            T![box] => {
-                box_pat(p);
+            c => {
-            }
+                let m = p.start();
-            _ => {
+                match c {
-                bind_pat(p, false);
+                    // test record_field_pat
+                    // fn foo() {
+                    //     let S { 0: 1 } = ();
+                    //     let S { x: 1 } = ();
+                    // }
+                    IDENT | INT_NUMBER if p.nth(1) == T![:] => {
+                        name_ref_or_index(p);
+                        p.bump(T![:]);
+                        pattern(p);
+                    }
+                    T![box] => {
+                        // FIXME: not all box patterns should be allowed
+                        box_pat(p);
+                    }
+                    _ => {
+                        bind_pat(p, false);
+                    }
+                }
+                m.complete(p, RECORD_FIELD_PAT);
            }
        }
        if !p.at(T!['}']) {
@@ -210,26 +226,6 @@ fn record_field_pat_list(p: &mut Parser) {
    m.complete(p, RECORD_FIELD_PAT_LIST);
 }
-// test record_field_pat
-// fn foo() {
-//     let S { 0: 1 } = ();
-//     let S { x: 1 } = ();
-// }
-fn record_field_pat(p: &mut Parser) {
-    assert!(p.at(IDENT) || p.at(INT_NUMBER));
-    assert!(p.nth(1) == T![:]);
-    let m = p.start();
-    if !p.eat(INT_NUMBER) {
-        name(p)
-    }
-    p.bump_any();
-    pattern(p);
-    m.complete(p, RECORD_FIELD_PAT);
-}
 // test placeholder_pat
 // fn main() { let _ = (); }
 fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 99c6b7219..7fca5661e 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -18,8 +18,8 @@ use crate::{
 pub use self::{
    expr_extensions::{ArrayExprKind, BinOp, ElseBranch, LiteralKind, PrefixOp, RangeOp},
    extensions::{
-        AttrKind, FieldKind, PathSegmentKind, SelfParamKind, SlicePatComponents, StructKind,
+        AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents,
-        TypeBoundKind, VisibilityKind,
+        StructKind, TypeBoundKind, VisibilityKind,
    },
    generated::{nodes::*, tokens::*},
    tokens::*,
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index 76b7655e6..f2ea5088e 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -1,6 +1,8 @@
 //! Various extension methods to ast Nodes, which are hard to code-generate.
 //! Extensions for various expressions live in a sibling `expr_extensions` module.
+use std::fmt;
 use itertools::Itertools;
 use ra_parser::SyntaxKind;
@@ -187,6 +189,64 @@ impl ast::StructDef {
    }
 }
+impl ast::RecordField {
+    pub fn for_field_name(field_name: &ast::NameRef) -> Option<ast::RecordField> {
+        let candidate =
+            field_name.syntax().parent().and_then(ast::RecordField::cast).or_else(|| {
+                field_name.syntax().ancestors().nth(4).and_then(ast::RecordField::cast)
+            })?;
+        if candidate.field_name().as_ref() == Some(field_name) {
+            Some(candidate)
+        } else {
+            None
+        }
+    }
+    /// Deals with field init shorthand
+    pub fn field_name(&self) -> Option<ast::NameRef> {
+        if let Some(name_ref) = self.name_ref() {
+            return Some(name_ref);
+        }
+        if let Some(ast::Expr::PathExpr(expr)) = self.expr() {
+            let path = expr.path()?;
+            let segment = path.segment()?;
+            let name_ref = segment.name_ref()?;
+            if path.qualifier().is_none() {
+                return Some(name_ref);
+            }
+        }
+        None
+    }
+}
+pub enum NameOrNameRef {
+    Name(ast::Name),
+    NameRef(ast::NameRef),
+}
+impl fmt::Display for NameOrNameRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            NameOrNameRef::Name(it) => fmt::Display::fmt(it, f),
+            NameOrNameRef::NameRef(it) => fmt::Display::fmt(it, f),
+        }
+    }
+}
+impl ast::RecordFieldPat {
+    /// Deals with field init shorthand
+    pub fn field_name(&self) -> Option<NameOrNameRef> {
+        if let Some(name_ref) = self.name_ref() {
+            return Some(NameOrNameRef::NameRef(name_ref));
+        }
+        if let Some(ast::Pat::BindPat(pat)) = self.pat() {
+            let name = pat.name()?;
+            return Some(NameOrNameRef::Name(name));
+        }
+        None
+    }
+}
 impl ast::EnumVariant {
    pub fn parent_enum(&self) -> ast::EnumDef {
        self.syntax()
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index f1098755b..188f0df96 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -1806,8 +1806,8 @@ impl AstNode for RecordFieldPat {
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for RecordFieldPat {}
-impl ast::NameOwner for RecordFieldPat {}
 impl RecordFieldPat {
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index f39559e9e..0f4a50be4 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -100,6 +100,9 @@ pub fn expr_empty_block() -> ast::Expr {
 pub fn expr_unimplemented() -> ast::Expr {
    expr_from_text("unimplemented!()")
 }
+pub fn expr_todo() -> ast::Expr {
+    expr_from_text("todo!()")
+}
 pub fn expr_path(path: ast::Path) -> ast::Expr {
    expr_from_text(&path.to_string())
 }
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index f0e16dc2b..a796e78b1 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -19,6 +19,11 @@
 //! [RFC]: <https://github.com/rust-lang/rfcs/pull/2256>
 //! [Swift]: <https://github.com/apple/swift/blob/13d593df6f359d0cb2fc81cfaac273297c539455/lib/Syntax/README.md>
+#[allow(unused)]
+macro_rules! eprintln {
+    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
+}
 mod syntax_node;
 mod syntax_error;
 mod parsing;
diff --git a/crates/ra_syntax/test_data/parser/inline/err/0014_record_literal_before_ellipsis_recovery.rast b/crates/ra_syntax/test_data/parser/inline/err/0014_record_literal_before_ellipsis_recovery.rast
new file mode 100644
index 000000000..75043c9c0
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/err/0014_record_literal_before_ellipsis_recovery.rast
@@ -0,0 +1,49 @@
+SOURCE_FILE@[0; 45)
+  FN_DEF@[0; 44)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 44)
+      BLOCK@[10; 44)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        RECORD_LIT@[16; 42)
+          PATH@[16; 17)
+            PATH_SEGMENT@[16; 17)
+              NAME_REF@[16; 17)
+                IDENT@[16; 17) "S"
+          WHITESPACE@[17; 18) " "
+          RECORD_FIELD_LIST@[18; 42)
+            L_CURLY@[18; 19) "{"
+            WHITESPACE@[19; 20) " "
+            RECORD_FIELD@[20; 40)
+              NAME_REF@[20; 25)
+                IDENT@[20; 25) "field"
+              WHITESPACE@[25; 26) " "
+              RANGE_EXPR@[26; 40)
+                DOT2@[26; 28) ".."
+                CALL_EXPR@[28; 40)
+                  PATH_EXPR@[28; 38)
+                    PATH@[28; 38)
+                      PATH@[28; 29)
+                        PATH_SEGMENT@[28; 29)
+                          NAME_REF@[28; 29)
+                            IDENT@[28; 29) "S"
+                      COLON2@[29; 31) "::"
+                      PATH_SEGMENT@[31; 38)
+                        NAME_REF@[31; 38)
+                          IDENT@[31; 38) "default"
+                  ARG_LIST@[38; 40)
+                    L_PAREN@[38; 39) "("
+                    R_PAREN@[39; 40) ")"
+            WHITESPACE@[40; 41) " "
+            R_CURLY@[41; 42) "}"
+        WHITESPACE@[42; 43) "\n"
+        R_CURLY@[43; 44) "}"
+  WHITESPACE@[44; 45) "\n"
+error [25; 25): expected COLON
diff --git a/crates/ra_syntax/test_data/parser/inline/err/0014_record_literal_before_ellipsis_recovery.rs b/crates/ra_syntax/test_data/parser/inline/err/0014_record_literal_before_ellipsis_recovery.rs
new file mode 100644
index 000000000..a4e5b2f69
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/err/0014_record_literal_before_ellipsis_recovery.rs
@@ -0,0 +1,3 @@
+fn main() {
+    S { field ..S::default() }
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0061_record_lit.rast b/crates/ra_syntax/test_data/parser/inline/ok/0061_record_lit.rast
index f4206858b..89a611799 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0061_record_lit.rast
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0061_record_lit.rast
@@ -35,8 +35,11 @@ SOURCE_FILE@[0; 112)
              L_CURLY@[27; 28) "{"
              WHITESPACE@[28; 29) " "
              RECORD_FIELD@[29; 30)
-                NAME_REF@[29; 30)
+                PATH_EXPR@[29; 30)
-                  IDENT@[29; 30) "x"
+                  PATH@[29; 30)
+                    PATH_SEGMENT@[29; 30)
+                      NAME_REF@[29; 30)
+                        IDENT@[29; 30) "x"
              COMMA@[30; 31) ","
              WHITESPACE@[31; 32) " "
              RECORD_FIELD@[32; 37)
@@ -62,8 +65,11 @@ SOURCE_FILE@[0; 112)
              L_CURLY@[48; 49) "{"
              WHITESPACE@[49; 50) " "
              RECORD_FIELD@[50; 51)
-                NAME_REF@[50; 51)
+                PATH_EXPR@[50; 51)
-                  IDENT@[50; 51) "x"
+                  PATH@[50; 51)
+                    PATH_SEGMENT@[50; 51)
+                      NAME_REF@[50; 51)
+                        IDENT@[50; 51) "x"
              COMMA@[51; 52) ","
              WHITESPACE@[52; 53) " "
              RECORD_FIELD@[53; 58)
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast
index c2614543c..fcd099de9 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0102_record_field_pat_list.rast
@@ -44,18 +44,20 @@ SOURCE_FILE@[0; 119)
            RECORD_FIELD_PAT_LIST@[40; 56)
              L_CURLY@[40; 41) "{"
              WHITESPACE@[41; 42) " "
-              BIND_PAT@[42; 43)
+              RECORD_FIELD_PAT@[42; 43)
-                NAME@[42; 43)
+                BIND_PAT@[42; 43)
-                  IDENT@[42; 43) "f"
+                  NAME@[42; 43)
+                    IDENT@[42; 43) "f"
              COMMA@[43; 44) ","
              WHITESPACE@[44; 45) " "
-              BIND_PAT@[45; 54)
+              RECORD_FIELD_PAT@[45; 54)
-                REF_KW@[45; 48) "ref"
+                BIND_PAT@[45; 54)
-                WHITESPACE@[48; 49) " "
+                  REF_KW@[45; 48) "ref"
-                MUT_KW@[49; 52) "mut"
+                  WHITESPACE@[48; 49) " "
-                WHITESPACE@[52; 53) " "
+                  MUT_KW@[49; 52) "mut"
-                NAME@[53; 54)
+                  WHITESPACE@[52; 53) " "
-                  IDENT@[53; 54) "g"
+                  NAME@[53; 54)
+                    IDENT@[53; 54) "g"
              WHITESPACE@[54; 55) " "
              R_CURLY@[55; 56) "}"
          WHITESPACE@[56; 57) " "
@@ -79,7 +81,7 @@ SOURCE_FILE@[0; 119)
              L_CURLY@[73; 74) "{"
              WHITESPACE@[74; 75) " "
              RECORD_FIELD_PAT@[75; 79)
-                NAME@[75; 76)
+                NAME_REF@[75; 76)
                  IDENT@[75; 76) "h"
                COLON@[76; 77) ":"
                WHITESPACE@[77; 78) " "
@@ -110,7 +112,7 @@ SOURCE_FILE@[0; 119)
              L_CURLY@[101; 102) "{"
              WHITESPACE@[102; 103) " "
              RECORD_FIELD_PAT@[103; 107)
-                NAME@[103; 104)
+                NAME_REF@[103; 104)
                  IDENT@[103; 104) "h"
                COLON@[104; 105) ":"
                WHITESPACE@[105; 106) " "
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast
index f75673070..1d245f8f3 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0143_box_pat.rast
@@ -44,16 +44,17 @@ SOURCE_FILE@[0; 118)
              RECORD_FIELD_PAT_LIST@[50; 81)
                L_CURLY@[50; 51) "{"
                WHITESPACE@[51; 52) " "
-                BOX_PAT@[52; 57)
+                RECORD_FIELD_PAT@[52; 57)
-                  BOX_KW@[52; 55) "box"
+                  BOX_PAT@[52; 57)
-                  WHITESPACE@[55; 56) " "
+                    BOX_KW@[52; 55) "box"
-                  BIND_PAT@[56; 57)
+                    WHITESPACE@[55; 56) " "
-                    NAME@[56; 57)
+                    BIND_PAT@[56; 57)
-                      IDENT@[56; 57) "i"
+                      NAME@[56; 57)
+                        IDENT@[56; 57) "i"
                COMMA@[57; 58) ","
                WHITESPACE@[58; 59) " "
                RECORD_FIELD_PAT@[59; 79)
-                  NAME@[59; 60)
+                  NAME_REF@[59; 60)
                    IDENT@[59; 60) "j"
                  COLON@[60; 61) ":"
                  WHITESPACE@[61; 62) " "
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast b/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast
index 0d786f597..cac2ffdcf 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0145_record_field_pat.rast
@@ -25,7 +25,8 @@ SOURCE_FILE@[0; 63)
              L_CURLY@[21; 22) "{"
              WHITESPACE@[22; 23) " "
              RECORD_FIELD_PAT@[23; 27)
-                INT_NUMBER@[23; 24) "0"
+                NAME_REF@[23; 24)
+                  INT_NUMBER@[23; 24) "0"
                COLON@[24; 25) ":"
                WHITESPACE@[25; 26) " "
                LITERAL_PAT@[26; 27)
@@ -54,7 +55,7 @@ SOURCE_FILE@[0; 63)
              L_CURLY@[46; 47) "{"
              WHITESPACE@[47; 48) " "
              RECORD_FIELD_PAT@[48; 52)
-                NAME@[48; 49)
+                NAME_REF@[48; 49)
                  IDENT@[48; 49) "x"
                COLON@[49; 50) ":"
                WHITESPACE@[50; 51) " "
diff --git a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast
index 9b5954ebd..d0623ba90 100644
--- a/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast
+++ b/crates/ra_syntax/test_data/parser/ok/0063_trait_fn_patterns.rast
@@ -68,14 +68,16 @@ SOURCE_FILE@[0; 170)
              RECORD_FIELD_PAT_LIST@[59; 67)
                L_CURLY@[59; 60) "{"
                WHITESPACE@[60; 61) " "
-                BIND_PAT@[61; 62)
+                RECORD_FIELD_PAT@[61; 62)
-                  NAME@[61; 62)
+                  BIND_PAT@[61; 62)
-                    IDENT@[61; 62) "a"
+                    NAME@[61; 62)
+                      IDENT@[61; 62) "a"
                COMMA@[62; 63) ","
                WHITESPACE@[63; 64) " "
-                BIND_PAT@[64; 65)
+                RECORD_FIELD_PAT@[64; 65)
-                  NAME@[64; 65)
+                  BIND_PAT@[64; 65)
-                    IDENT@[64; 65) "b"
+                    NAME@[64; 65)
+                      IDENT@[64; 65) "b"
                WHITESPACE@[65; 66) " "
                R_CURLY@[66; 67) "}"
            COLON@[67; 68) ":"
diff --git a/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast
index b30030de3..5e96b695b 100644
--- a/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast
+++ b/crates/ra_syntax/test_data/parser/ok/0064_impl_fn_params.rast
@@ -71,14 +71,16 @@ SOURCE_FILE@[0; 137)
              RECORD_FIELD_PAT_LIST@[58; 66)
                L_CURLY@[58; 59) "{"
                WHITESPACE@[59; 60) " "
-                BIND_PAT@[60; 61)
+                RECORD_FIELD_PAT@[60; 61)
-                  NAME@[60; 61)
+                  BIND_PAT@[60; 61)
-                    IDENT@[60; 61) "a"
+                    NAME@[60; 61)
+                      IDENT@[60; 61) "a"
                COMMA@[61; 62) ","
                WHITESPACE@[62; 63) " "
-                BIND_PAT@[63; 64)
+                RECORD_FIELD_PAT@[63; 64)
-                  NAME@[63; 64)
+                  BIND_PAT@[63; 64)
-                    IDENT@[63; 64) "b"
+                    NAME@[63; 64)
+                      IDENT@[63; 64) "b"
                WHITESPACE@[64; 65) " "
                R_CURLY@[65; 66) "}"
            COLON@[66; 67) ":"
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
index 3cf394bb4..f5981588a 100644
--- a/crates/rust-analyzer/src/bin/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -35,6 +35,13 @@ pub(crate) enum Command {
        what: BenchWhat,
        load_output_dirs: bool,
    },
+    Diagnostics {
+        path: PathBuf,
+        load_output_dirs: bool,
+        /// Include files which are not modules. In rust-analyzer
+        /// this would include the parser test files.
+        all: bool,
+    },
    RunServer,
    Version,
 }
@@ -209,6 +216,38 @@ ARGS:
                let load_output_dirs = matches.contains("--load-output-dirs");
                Command::Bench { path, what, load_output_dirs }
            }
+            "diagnostics" => {
+                if matches.contains(["-h", "--help"]) {
+                    eprintln!(
+                        "\
+ra-cli-diagnostics
+USAGE:
+    rust-analyzer diagnostics [FLAGS] [PATH]
+FLAGS:
+    -h, --help              Prints help information
+        --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
+        --all               Include all files rather than only modules
+ARGS:
+    <PATH>"
+                    );
+                    return Ok(Err(HelpPrinted));
+                }
+                let load_output_dirs = matches.contains("--load-output-dirs");
+                let all = matches.contains("--all");
+                let path = {
+                    let mut trailing = matches.free()?;
+                    if trailing.len() != 1 {
+                        bail!("Invalid flags");
+                    }
+                    trailing.pop().unwrap().into()
+                };
+                Command::Diagnostics { path, load_output_dirs, all }
+            }
            _ => {
                eprintln!(
                    "\
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 608f4f67b..7cfc44f01 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -39,6 +39,10 @@ fn main() -> Result<()> {
            cli::analysis_bench(args.verbosity, path.as_ref(), what, load_output_dirs)?
        }
+        args::Command::Diagnostics { path, load_output_dirs, all } => {
+            cli::diagnostics(path.as_ref(), load_output_dirs, all)?
+        }
        args::Command::RunServer => run_server()?,
        args::Command::Version => println!("rust-analyzer {}", env!("REV")),
    }
diff --git a/crates/rust-analyzer/src/cli.rs b/crates/rust-analyzer/src/cli.rs
index c9738d101..a865a7c7e 100644
--- a/crates/rust-analyzer/src/cli.rs
+++ b/crates/rust-analyzer/src/cli.rs
@@ -3,6 +3,7 @@
 mod load_cargo;
 mod analysis_stats;
 mod analysis_bench;
+mod diagnostics;
 mod progress_report;
 use std::io::Read;
@@ -12,6 +13,10 @@ use ra_ide::{file_structure, Analysis};
 use ra_prof::profile;
 use ra_syntax::{AstNode, SourceFile};
+pub use analysis_bench::{analysis_bench, BenchWhat, Position};
+pub use analysis_stats::analysis_stats;
+pub use diagnostics::diagnostics;
 #[derive(Clone, Copy)]
 pub enum Verbosity {
    Spammy,
@@ -60,9 +65,6 @@ pub fn highlight(rainbow: bool) -> Result<()> {
    Ok(())
 }
-pub use analysis_bench::{analysis_bench, BenchWhat, Position};
-pub use analysis_stats::analysis_stats;
 fn file() -> Result<SourceFile> {
    let text = read_stdin()?;
    Ok(SourceFile::parse(&text).tree())
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 75cf2dae5..e9ee0b888 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -163,10 +163,7 @@ pub fn analysis_stats(
                if let Ok(src) = src {
                    let original_file = src.file_id.original_file(db);
                    let line_index = host.analysis().file_line_index(original_file).unwrap();
-                    let text_range = src.value.either(
+                    let text_range = src.value.syntax_node_ptr().range();
-                        |it| it.syntax_node_ptr().range(),
-                        |it| it.syntax_node_ptr().range(),
-                    );
                    let (start, end) = (
                        line_index.line_col(text_range.start()),
                        line_index.line_col(text_range.end()),
@@ -192,12 +189,7 @@ pub fn analysis_stats(
                        // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly
                        // But also, we should just turn the type mismatches into diagnostics and provide these
                        let root = db.parse_or_expand(src.file_id).unwrap();
-                        let node = src.map(|e| {
+                        let node = src.map(|e| e.to_node(&root).syntax().clone());
-                            e.either(
-                                |p| p.to_node(&root).syntax().clone(),
-                                |p| p.to_node(&root).syntax().clone(),
-                            )
-                        });
                        let original_range = original_range(db, node.as_ref());
                        let path = db.file_relative_path(original_range.file_id);
                        let line_index =
diff --git a/crates/rust-analyzer/src/cli/diagnostics.rs b/crates/rust-analyzer/src/cli/diagnostics.rs
new file mode 100644
index 000000000..92664b415
--- /dev/null
+++ b/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -0,0 +1,74 @@
+//! Analyze all modules in a project for diagnostics. Exits with a non-zero status
+//! code if any errors are found.
+use anyhow::anyhow;
+use ra_db::SourceDatabaseExt;
+use ra_ide::Severity;
+use std::{collections::HashSet, path::Path};
+use crate::cli::{load_cargo::load_cargo, Result};
+use hir::Semantics;
+pub fn diagnostics(path: &Path, load_output_dirs: bool, all: bool) -> Result<()> {
+    let (host, roots) = load_cargo(path, load_output_dirs)?;
+    let db = host.raw_database();
+    let analysis = host.analysis();
+    let semantics = Semantics::new(db);
+    let members = roots
+        .into_iter()
+        .filter_map(|(source_root_id, project_root)| {
+            // filter out dependencies
+            if project_root.is_member() {
+                Some(source_root_id)
+            } else {
+                None
+            }
+        })
+        .collect::<HashSet<_>>();
+    let mut found_error = false;
+    let mut visited_files = HashSet::new();
+    for source_root_id in members {
+        for file_id in db.source_root(source_root_id).walk() {
+            // Filter out files which are not actually modules (unless `--all` flag is
+            // passed). In the rust-analyzer repository this filters out the parser test files.
+            if semantics.to_module_def(file_id).is_some() || all {
+                if !visited_files.contains(&file_id) {
+                    let crate_name = if let Some(module) = semantics.to_module_def(file_id) {
+                        if let Some(name) = module.krate().display_name(db) {
+                            format!("{}", name)
+                        } else {
+                            String::from("unknown")
+                        }
+                    } else {
+                        String::from("unknown")
+                    };
+                    println!(
+                        "processing crate: {}, module: {}",
+                        crate_name,
+                        db.file_relative_path(file_id)
+                    );
+                    for diagnostic in analysis.diagnostics(file_id).unwrap() {
+                        if matches!(diagnostic.severity, Severity::Error) {
+                            found_error = true;
+                        }
+                        println!("{:?}", diagnostic);
+                    }
+                    visited_files.insert(file_id);
+                }
+            }
+        }
+    }
+    println!();
+    println!("diagnostic scan complete");
+    if found_error {
+        println!();
+        Err(anyhow!("diagnostic error detected"))
+    } else {
+        Ok(())
+    }
+}
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 3b60c55f3..4164bfd5e 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -395,7 +395,7 @@ pub fn skip_slow_tests() -> bool {
    should_skip
 }
-const REWRITE: bool = true;
+const REWRITE: bool = false;
 /// Asserts that `expected` and `actual` strings are equal. If they differ only
 /// in trailing or leading whitespace the test won't fail and