26 files changed, 596 insertions, 150 deletions
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index b63b4d81a..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!()
 }
 "#####,
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/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_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_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/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 6caa87db4..79abe55ce 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -33,6 +33,7 @@ use crate::{
 };
 use super::{ExprSource, PatSource};
+use ast::AstChildren;
 pub(super) fn lower(
    db: &dyn DefDatabase,
@@ -598,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());
@@ -616,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 =
@@ -665,6 +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,
        };
@@ -679,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 5dfde75d9..ccb682f9a 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -16,7 +16,7 @@ use ra_syntax::ast::{
 use crate::{
    attr::Attrs,
    db::DefDatabase,
-    path::{path, GenericArgs, Path},
+    path::{path, AssociatedTypeBinding, GenericArgs, Path},
    src::HasSource,
    type_ref::{Mutability, TypeBound, TypeRef},
    visibility::RawVisibility,
@@ -96,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)
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/path.rs b/crates/ra_hir_def/src/path.rs
index 91c7b3e09..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.
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_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 c482cf619..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),
@@ -1507,6 +1541,67 @@ mod tests {
    }
    #[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 {
@@ -1645,11 +1740,7 @@ mod false_negatives {
        ";
        // This is a false negative.
-        // The `..` pattern is currently lowered to a single `Pat::Wild`
+        // We don't currently handle tuple patterns with ellipsis.
-        // no matter how many fields the `..` pattern is covering. This
-        // causes the match arm in this test not to type check against
-        // the match expression, which causes this diagnostic not to
-        // fire.
        check_no_diagnostic(content);
    }
@@ -1664,32 +1755,7 @@ mod false_negatives {
        ";
        // This is a false negative.
-        // See comments on `tuple_of_bools_with_ellipsis_at_end_missing_arm`.
+        // We don't currently handle tuple patterns with ellipsis.
-        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 => {},
-                }
-            }
-        ";
-        // This is a false negative.
-        // The `..` pattern is currently lowered to a single `Pat::Wild`
-        // no matter how many fields the `..` pattern is covering. This
-        // causes us to return a `MatchCheckErr::MalformedMatchArm` in
-        // `Pat::specialize_constructor`.
        check_no_diagnostic(content);
    }
 }
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/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 af8c63d64..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#"
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index 12ffa69a0..55eb0ffcb 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -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(
@@ -745,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(
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_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index 9fb5cb058..31e9b22e7 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -607,12 +607,13 @@ impl<'a> TreeSink for TtTreeSink<'a> {
            let text: SmolStr = match self.cursor.token_tree() {
                Some(tt::TokenTree::Leaf(leaf)) => {
                    // Mark the range if needed
-                    let id = match leaf {
+                    let (text, id) = match leaf {
-                        tt::Leaf::Ident(ident) => ident.id,
+                        tt::Leaf::Ident(ident) => (ident.text.clone(), ident.id),
-                        tt::Leaf::Punct(punct) => punct.id,
+                        tt::Leaf::Punct(punct) => {
-                        tt::Leaf::Literal(lit) => lit.id,
+                            (SmolStr::new_inline_from_ascii(1, &[punct.char as u8]), punct.id)
+                        }
+                        tt::Leaf::Literal(lit) => (lit.text.clone(), lit.id),
                    };
-                    let text = SmolStr::new(format!("{}", leaf));
                    let range = TextRange::offset_len(self.text_pos, TextUnit::of_str(&text));
                    self.token_map.insert(id, range);
                    self.cursor = self.cursor.bump();
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/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(())
+    }
+}