83 files changed, 1854 insertions, 2387 deletions
diff --git a/crates/expect/Cargo.toml b/crates/expect/Cargo.toml
index f8fa29e4e..77775630d 100644
--- a/crates/expect/Cargo.toml
+++ b/crates/expect/Cargo.toml
@@ -3,6 +3,7 @@ name = "expect"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 edition = "2018"
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index dc26b8ce7..bea485694 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "flycheck"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/paths/Cargo.toml b/crates/paths/Cargo.toml
index 646ee7fd5..cbe2c26e2 100644
--- a/crates/paths/Cargo.toml
+++ b/crates/paths/Cargo.toml
@@ -3,6 +3,7 @@ name = "paths"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 edition = "2018"
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_arena/Cargo.toml b/crates/ra_arena/Cargo.toml
index d287dbb73..66c3738f4 100644
--- a/crates/ra_arena/Cargo.toml
+++ b/crates/ra_arena/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_arena"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 3bcf58ba4..bd2905f08 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_assists"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
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 d6aaf53f1..f185e61e5 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -158,6 +158,9 @@ fn add_missing_impl_members_inner(
            .map(|it| ast_transform::apply(&*ast_transform, it))
            .map(|it| match it {
                ast::AssocItem::FnDef(def) => ast::AssocItem::FnDef(add_body(def)),
+                ast::AssocItem::TypeAliasDef(def) => {
+                    ast::AssocItem::TypeAliasDef(def.remove_bounds())
+                }
                _ => it,
            })
            .map(|it| edit::remove_attrs_and_docs(&it));
@@ -684,4 +687,26 @@ impl Foo<T> for S<T> {
 }"#,
        )
    }
+    #[test]
+    fn test_assoc_type_bounds_are_removed() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Tr {
+    type Ty: Copy + 'static;
+}
+impl Tr for ()<|> {
+}"#,
+            r#"
+trait Tr {
+    type Ty: Copy + 'static;
+}
+impl Tr for () {
+    $0type Ty;
+}"#,
+        )
+    }
 }
diff --git a/crates/ra_cfg/Cargo.toml b/crates/ra_cfg/Cargo.toml
index 9165076a5..6425cd6d6 100644
--- a/crates/ra_cfg/Cargo.toml
+++ b/crates/ra_cfg/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_cfg"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index 889142442..5f334d04f 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_db"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_fmt/Cargo.toml b/crates/ra_fmt/Cargo.toml
index e9d057afc..b4ef93f2b 100644
--- a/crates/ra_fmt/Cargo.toml
+++ b/crates/ra_fmt/Cargo.toml
@@ -4,6 +4,7 @@ name = "ra_fmt"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 512676c99..c260bb193 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_hir"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 9222009fe..42c9ca189 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -25,11 +25,8 @@ use hir_expand::{
 use hir_ty::{
    autoderef,
    display::{HirDisplayError, HirFormatter},
-    expr::ExprValidator,
+    method_resolution, ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs,
-    method_resolution,
+    TraitEnvironment, Ty, TyDefId, TypeCtor,
-    unsafe_validation::UnsafeValidator,
-    ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs, TraitEnvironment, Ty,
-    TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
@@ -680,13 +677,7 @@ impl Function {
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
-        let _p = profile("Function::diagnostics");
+        hir_ty::diagnostics::validate_body(db, self.id.into(), sink)
-        let infer = db.infer(self.id.into());
-        infer.add_diagnostics(db, self.id, sink);
-        let mut validator = ExprValidator::new(self.id, infer.clone(), sink);
-        validator.validate_body(db);
-        let mut validator = UnsafeValidator::new(self.id, infer, sink);
-        validator.validate_body(db);
    }
 }
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index f74b78b23..ecb54f653 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -18,7 +18,7 @@ use hir_def::{
 };
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
-    expr::{record_literal_missing_fields, record_pattern_missing_fields},
+    diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
    InferenceResult, Substs, Ty,
 };
 use ra_syntax::{
@@ -352,7 +352,7 @@ impl SourceAnalyzer {
        let macro_call_id = macro_call.as_call_id(db.upcast(), krate, |path| {
            self.resolver.resolve_path_as_macro(db.upcast(), &path)
        })?;
-        Some(macro_call_id.as_file())
+        Some(macro_call_id.as_file()).filter(|it| it.expansion_level(db.upcast()) < 64)
    }
    pub(crate) fn resolve_variant(
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index cf5ebbaf5..1ec619b42 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_hir_def"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index aa335f1e3..88a8ef9bf 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -27,6 +27,7 @@ pub struct FunctionData {
    /// can be called as a method.
    pub has_self_param: bool,
    pub is_unsafe: bool,
+    pub is_varargs: bool,
    pub visibility: RawVisibility,
 }
@@ -43,6 +44,7 @@ impl FunctionData {
            attrs: item_tree.attrs(ModItem::from(loc.id.value).into()).clone(),
            has_self_param: func.has_self_param,
            is_unsafe: func.is_unsafe,
+            is_varargs: func.is_varargs,
            visibility: item_tree[func.visibility].clone(),
        })
    }
diff --git a/crates/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs
index 3e603bd55..da79d8ffd 100644
--- a/crates/ra_hir_def/src/item_tree.rs
+++ b/crates/ra_hir_def/src/item_tree.rs
@@ -503,6 +503,7 @@ pub struct Function {
    pub has_self_param: bool,
    pub is_unsafe: bool,
    pub params: Box<[TypeRef]>,
+    pub is_varargs: bool,
    pub ret_type: TypeRef,
    pub ast_id: FileAstId<ast::FnDef>,
 }
diff --git a/crates/ra_hir_def/src/item_tree/lower.rs b/crates/ra_hir_def/src/item_tree/lower.rs
index 0b1509e13..f79b8fca3 100644
--- a/crates/ra_hir_def/src/item_tree/lower.rs
+++ b/crates/ra_hir_def/src/item_tree/lower.rs
@@ -219,21 +219,20 @@ impl Ctx {
    fn lower_tuple_fields(&mut self, fields: &ast::TupleFieldDefList) -> IdRange<Field> {
        let start = self.next_field_idx();
        for (i, field) in fields.fields().enumerate() {
-            if let Some(data) = self.lower_tuple_field(i, &field) {
+            let data = self.lower_tuple_field(i, &field);
-                let idx = self.data().fields.alloc(data);
+            let idx = self.data().fields.alloc(data);
-                self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+            self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
-            }
        }
        let end = self.next_field_idx();
        IdRange::new(start..end)
    }
-    fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleFieldDef) -> Option<Field> {
+    fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleFieldDef) -> Field {
        let name = Name::new_tuple_field(idx);
        let visibility = self.lower_visibility(field);
-        let type_ref = self.lower_type_ref(&field.type_ref()?);
+        let type_ref = self.lower_type_ref_opt(field.type_ref());
        let res = Field { name, type_ref, visibility };
-        Some(res)
+        res
    }
    fn lower_union(&mut self, union: &ast::UnionDef) -> Option<FileItemTreeId<Union>> {
@@ -314,6 +313,14 @@ impl Ctx {
                params.push(type_ref);
            }
        }
+        let mut is_varargs = false;
+        if let Some(params) = func.param_list() {
+            if let Some(last) = params.params().last() {
+                is_varargs = last.dotdotdot_token().is_some();
+            }
+        }
        let ret_type = match func.ret_type().and_then(|rt| rt.type_ref()) {
            Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
            _ => TypeRef::unit(),
@@ -335,6 +342,7 @@ impl Ctx {
            has_self_param,
            is_unsafe: func.unsafe_token().is_some(),
            params: params.into_boxed_slice(),
+            is_varargs,
            ret_type,
            ast_id,
        };
diff --git a/crates/ra_hir_def/src/item_tree/tests.rs b/crates/ra_hir_def/src/item_tree/tests.rs
index a0431dbce..f26982985 100644
--- a/crates/ra_hir_def/src/item_tree/tests.rs
+++ b/crates/ra_hir_def/src/item_tree/tests.rs
@@ -240,9 +240,9 @@ fn smoke() {
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_const"))] }, input: None }]) }]
            > Const { name: Some(Name(Text("CONST"))), visibility: RawVisibilityId("pub(self)"), type_ref: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("u8"))] }, generic_args: [None] }), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ConstDef>(9) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_method"))] }, input: None }]) }]
-            > Function { name: Name(Text("method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Shared)], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(10) }
+            > Function { name: Name(Text("method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Shared)], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(10) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_dfl_method"))] }, input: None }]) }]
-            > Function { name: Name(Text("dfl_method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Mut)], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(11) }
+            > Function { name: Name(Text("dfl_method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Mut)], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(11) }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct0"))] }, input: None }]) }]
            Struct { name: Name(Text("Struct0")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), fields: Unit, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(3), kind: Unit }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct1"))] }, input: None }]) }]
@@ -275,12 +275,12 @@ fn simple_inner_items() {
            top-level items:
            Impl { generic_params: GenericParamsId(0), target_trait: Some(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("D"))] }, generic_args: [None] })), target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Response"))] }, generic_args: [Some(GenericArgs { args: [Type(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("T"))] }, generic_args: [None] }))], has_self_type: false, bindings: [] })] }), is_negative: false, items: [Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ImplDef>(0) }
-            > Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            > Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
            inner items:
            for AST FileAstId::<ra_syntax::ast::generated::nodes::ModuleItem>(2):
-            Function { name: Name(Text("end")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+            Function { name: Name(Text("end")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
        "#]],
    );
@@ -303,9 +303,9 @@ fn extern_attrs() {
            top-level items:
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }, Attr { path: ModPath { kind: Plain, segments: [Name(Text("block_attr"))] }, input: None }]) }]
-            Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }, Attr { path: ModPath { kind: Plain, segments: [Name(Text("block_attr"))] }, input: None }]) }]
-            Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+            Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
        "##]],
    );
 }
@@ -329,9 +329,9 @@ fn trait_attrs() {
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("trait_attr"))] }, input: None }]) }]
            Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::TraitDef>(0) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }]) }]
-            > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }]) }]
-            > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+            > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
        "##]],
    );
 }
@@ -355,9 +355,9 @@ fn impl_attrs() {
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("impl_attr"))] }, input: None }]) }]
            Impl { generic_params: GenericParamsId(4294967295), target_trait: None, target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Ty"))] }, generic_args: [None] }), is_negative: false, items: [Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ImplDef>(0) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }]) }]
-            > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }]) }]
-            > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+            > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
        "##]],
    );
 }
@@ -408,13 +408,13 @@ fn inner_item_attrs() {
            inner attrs: Attrs { entries: None }
            top-level items:
-            Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(0) }
+            Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(0) }
            inner items:
            for AST FileAstId::<ra_syntax::ast::generated::nodes::ModuleItem>(1):
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_inner"))] }, input: None }]) }]
-            Function { name: Name(Text("inner")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            Function { name: Name(Text("inner")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
        "##]],
    );
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index a35ac1024..d85a86c0a 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -36,6 +36,10 @@ use crate::{
    TraitLoc, TypeAliasLoc, UnionLoc,
 };
+const GLOB_RECURSION_LIMIT: usize = 100;
+const EXPANSION_DEPTH_LIMIT: usize = 128;
+const FIXED_POINT_LIMIT: usize = 8192;
 pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
    let crate_graph = db.crate_graph();
@@ -217,7 +221,7 @@ impl DefCollector<'_> {
                ReachedFixedPoint::Yes => break,
                ReachedFixedPoint::No => i += 1,
            }
-            if i == 10000 {
+            if i == FIXED_POINT_LIMIT {
                log::error!("name resolution is stuck");
                break;
            }
@@ -573,6 +577,7 @@ impl DefCollector<'_> {
        vis: Visibility,
        import_type: ImportType,
    ) {
+        self.db.check_canceled();
        self.update_recursive(module_id, resolutions, vis, import_type, 0)
    }
@@ -586,7 +591,7 @@ impl DefCollector<'_> {
        import_type: ImportType,
        depth: usize,
    ) {
-        if depth > 100 {
+        if depth > GLOB_RECURSION_LIMIT {
            // prevent stack overflows (but this shouldn't be possible)
            panic!("infinite recursion in glob imports!");
        }
@@ -609,14 +614,15 @@ impl DefCollector<'_> {
            .get(&module_id)
            .into_iter()
            .flat_map(|v| v.iter())
+            .filter(|(glob_importing_module, _)| {
+                // we know all resolutions have the same visibility (`vis`), so we
+                // just need to check that once
+                vis.is_visible_from_def_map(&self.def_map, *glob_importing_module)
+            })
            .cloned()
            .collect::<Vec<_>>();
        for (glob_importing_module, glob_import_vis) in glob_imports {
-            // we know all resolutions have the same visibility (`vis`), so we
-            // just need to check that once
-            if !vis.is_visible_from_def_map(&self.def_map, glob_importing_module) {
-                continue;
-            }
            self.update_recursive(
                glob_importing_module,
                resolutions,
@@ -677,10 +683,6 @@ impl DefCollector<'_> {
        self.unexpanded_attribute_macros = attribute_macros;
        for (module_id, macro_call_id, depth) in resolved {
-            if depth > 1024 {
-                log::debug!("Max macro expansion depth reached");
-                continue;
-            }
            self.collect_macro_expansion(module_id, macro_call_id, depth);
        }
@@ -717,6 +719,11 @@ impl DefCollector<'_> {
        macro_call_id: MacroCallId,
        depth: usize,
    ) {
+        if depth > EXPANSION_DEPTH_LIMIT {
+            mark::hit!(macro_expansion_overflow);
+            log::warn!("macro expansion is too deep");
+            return;
+        }
        let file_id: HirFileId = macro_call_id.as_file();
        let item_tree = self.db.item_tree(file_id);
        let mod_dir = self.mod_dirs[&module_id].clone();
diff --git a/crates/ra_hir_def/src/nameres/tests/macros.rs b/crates/ra_hir_def/src/nameres/tests/macros.rs
index 84480d9f6..c52341a07 100644
--- a/crates/ra_hir_def/src/nameres/tests/macros.rs
+++ b/crates/ra_hir_def/src/nameres/tests/macros.rs
@@ -660,3 +660,27 @@ fn expand_multiple_derive() {
    );
    assert_eq!(map.modules[map.root].scope.impls().len(), 2);
 }
+#[test]
+fn macro_expansion_overflow() {
+    mark::check!(macro_expansion_overflow);
+    compute_crate_def_map(
+        "
+macro_rules! a {
+    ($e:expr; $($t:tt)*) => {
+        b!($($t)*);
+    };
+    () => {};
+}
+macro_rules! b {
+    (static = $e:expr; $($t:tt)*) => {
+        a!($e; $($t)*);
+    };
+    () => {};
+}
+b! { static = #[] (); }
+",
+    );
+}
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index 86a77b704..e90b2a0b9 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -63,7 +63,7 @@ pub enum TypeRef {
    Array(Box<TypeRef> /*, Expr*/),
    Slice(Box<TypeRef>),
    /// A fn pointer. Last element of the vector is the return type.
-    Fn(Vec<TypeRef>),
+    Fn(Vec<TypeRef>, bool /*varargs*/),
    // For
    ImplTrait(Vec<TypeBound>),
    DynTrait(Vec<TypeBound>),
@@ -118,7 +118,12 @@ impl TypeRef {
                    .and_then(|rt| rt.type_ref())
                    .map(|it| TypeRef::from_ast(ctx, it))
                    .unwrap_or_else(|| TypeRef::Tuple(Vec::new()));
+                let mut is_varargs = false;
                let mut params = if let Some(pl) = inner.param_list() {
+                    if let Some(param) = pl.params().last() {
+                        is_varargs = param.dotdotdot_token().is_some();
+                    }
                    pl.params()
                        .map(|p| p.ascribed_type())
                        .map(|it| TypeRef::from_ast_opt(&ctx, it))
@@ -127,7 +132,7 @@ impl TypeRef {
                    Vec::new()
                };
                params.push(ret_ty);
-                TypeRef::Fn(params)
+                TypeRef::Fn(params, is_varargs)
            }
            // for types are close enough for our purposes to the inner type for now...
            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
@@ -158,7 +163,9 @@ impl TypeRef {
        fn go(type_ref: &TypeRef, f: &mut impl FnMut(&TypeRef)) {
            f(type_ref);
            match type_ref {
-                TypeRef::Fn(types) | TypeRef::Tuple(types) => types.iter().for_each(|t| go(t, f)),
+                TypeRef::Fn(types, _) | TypeRef::Tuple(types) => {
+                    types.iter().for_each(|t| go(t, f))
+                }
                TypeRef::RawPtr(type_ref, _)
                | TypeRef::Reference(type_ref, _)
                | TypeRef::Array(type_ref)
diff --git a/crates/ra_hir_expand/Cargo.toml b/crates/ra_hir_expand/Cargo.toml
index e5c9f3e99..6da0e2a16 100644
--- a/crates/ra_hir_expand/Cargo.toml
+++ b/crates/ra_hir_expand/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_hir_expand"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 5eac2605b..1cf6c1ba9 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -88,6 +88,25 @@ impl HirFileId {
        }
    }
+    pub fn expansion_level(self, db: &dyn db::AstDatabase) -> u32 {
+        let mut level = 0;
+        let mut curr = self;
+        while let HirFileIdRepr::MacroFile(macro_file) = curr.0 {
+            level += 1;
+            curr = match macro_file.macro_call_id {
+                MacroCallId::LazyMacro(id) => {
+                    let loc = db.lookup_intern_macro(id);
+                    loc.kind.file_id()
+                }
+                MacroCallId::EagerMacro(id) => {
+                    let loc = db.lookup_intern_eager_expansion(id);
+                    loc.file_id
+                }
+            };
+        }
+        level
+    }
    /// If this is a macro call, returns the syntax node of the call.
    pub fn call_node(self, db: &dyn db::AstDatabase) -> Option<InFile<SyntaxNode>> {
        match self.0 {
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 90368220b..78f5e55bb 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_hir_ty"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index 5b0dda634..d3ee9cf55 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -1,13 +1,30 @@
 //! FIXME: write short doc here
+mod expr;
+mod match_check;
+mod unsafe_check;
 use std::any::Any;
+use hir_def::DefWithBodyId;
+use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
 use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};
+use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
 use stdx::format_to;
-pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm, path::Path};
+use crate::db::HirDatabase;
-pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
+pub use crate::diagnostics::expr::{record_literal_missing_fields, record_pattern_missing_fields};
+pub fn validate_body(db: &dyn HirDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
+    let _p = profile("validate_body");
+    let infer = db.infer(owner);
+    infer.add_diagnostics(db, owner, sink);
+    let mut validator = expr::ExprValidator::new(owner, infer.clone(), sink);
+    validator.validate_body(db);
+    let mut validator = unsafe_check::UnsafeValidator::new(owner, infer, sink);
+    validator.validate_body(db);
+}
 #[derive(Debug)]
 pub struct NoSuchField {
@@ -227,3 +244,235 @@ impl AstDiagnostic for MismatchedArgCount {
        ast::CallExpr::cast(node).unwrap()
    }
 }
+#[cfg(test)]
+mod tests {
+    use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId};
+    use hir_expand::diagnostics::{Diagnostic, DiagnosticSink};
+    use ra_db::{fixture::WithFixture, FileId, SourceDatabase, SourceDatabaseExt};
+    use ra_syntax::{TextRange, TextSize};
+    use rustc_hash::FxHashMap;
+    use crate::{diagnostics::validate_body, test_db::TestDB};
+    impl TestDB {
+        fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+            let crate_graph = self.crate_graph();
+            for krate in crate_graph.iter() {
+                let crate_def_map = self.crate_def_map(krate);
+                let mut fns = Vec::new();
+                for (module_id, _) in crate_def_map.modules.iter() {
+                    for decl in crate_def_map[module_id].scope.declarations() {
+                        if let ModuleDefId::FunctionId(f) = decl {
+                            fns.push(f)
+                        }
+                    }
+                    for impl_id in crate_def_map[module_id].scope.impls() {
+                        let impl_data = self.impl_data(impl_id);
+                        for item in impl_data.items.iter() {
+                            if let AssocItemId::FunctionId(f) = item {
+                                fns.push(*f)
+                            }
+                        }
+                    }
+                }
+                for f in fns {
+                    let mut sink = DiagnosticSink::new(&mut cb);
+                    validate_body(self, f.into(), &mut sink);
+                }
+            }
+        }
+    }
+    pub(crate) fn check_diagnostics(ra_fixture: &str) {
+        let db = TestDB::with_files(ra_fixture);
+        let annotations = db.extract_annotations();
+        let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
+        db.diagnostics(|d| {
+            // FXIME: macros...
+            let file_id = d.source().file_id.original_file(&db);
+            let range = d.syntax_node(&db).text_range();
+            let message = d.message().to_owned();
+            actual.entry(file_id).or_default().push((range, message));
+        });
+        for (file_id, diags) in actual.iter_mut() {
+            diags.sort_by_key(|it| it.0.start());
+            let text = db.file_text(*file_id);
+            // For multiline spans, place them on line start
+            for (range, content) in diags {
+                if text[*range].contains('\n') {
+                    *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
+                    *content = format!("... {}", content);
+                }
+            }
+        }
+        assert_eq!(annotations, actual);
+    }
+    #[test]
+    fn no_such_field_diagnostics() {
+        check_diagnostics(
+            r#"
+struct S { foo: i32, bar: () }
+impl S {
+    fn new() -> S {
+        S {
+        //^... Missing structure fields:
+        //|    - bar
+            foo: 92,
+            baz: 62,
+          //^^^^^^^ no such field
+        }
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn no_such_field_with_feature_flag_diagnostics() {
+        check_diagnostics(
+            r#"
+//- /lib.rs crate:foo cfg:feature=foo
+struct MyStruct {
+    my_val: usize,
+    #[cfg(feature = "foo")]
+    bar: bool,
+}
+impl MyStruct {
+    #[cfg(feature = "foo")]
+    pub(crate) fn new(my_val: usize, bar: bool) -> Self {
+        Self { my_val, bar }
+    }
+    #[cfg(not(feature = "foo"))]
+    pub(crate) fn new(my_val: usize, _bar: bool) -> Self {
+        Self { my_val }
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn no_such_field_enum_with_feature_flag_diagnostics() {
+        check_diagnostics(
+            r#"
+//- /lib.rs crate:foo cfg:feature=foo
+enum Foo {
+    #[cfg(not(feature = "foo"))]
+    Buz,
+    #[cfg(feature = "foo")]
+    Bar,
+    Baz
+}
+fn test_fn(f: Foo) {
+    match f {
+        Foo::Bar => {},
+        Foo::Baz => {},
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
+        check_diagnostics(
+            r#"
+//- /lib.rs crate:foo cfg:feature=foo
+struct S {
+    #[cfg(feature = "foo")]
+    foo: u32,
+    #[cfg(not(feature = "foo"))]
+    bar: u32,
+}
+impl S {
+    #[cfg(feature = "foo")]
+    fn new(foo: u32) -> Self {
+        Self { foo }
+    }
+    #[cfg(not(feature = "foo"))]
+    fn new(bar: u32) -> Self {
+        Self { bar }
+    }
+    fn new2(bar: u32) -> Self {
+        #[cfg(feature = "foo")]
+        { Self { foo: bar } }
+        #[cfg(not(feature = "foo"))]
+        { Self { bar } }
+    }
+    fn new2(val: u32) -> Self {
+        Self {
+            #[cfg(feature = "foo")]
+            foo: val,
+            #[cfg(not(feature = "foo"))]
+            bar: val,
+        }
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn no_such_field_with_type_macro() {
+        check_diagnostics(
+            r#"
+macro_rules! Type { () => { u32 }; }
+struct Foo { bar: Type![] }
+impl Foo {
+    fn new() -> Self {
+        Foo { bar: 0 }
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn missing_record_pat_field_diagnostic() {
+        check_diagnostics(
+            r#"
+struct S { foo: i32, bar: () }
+fn baz(s: S) {
+    let S { foo: _ } = s;
+        //^^^^^^^^^^ Missing structure fields:
+        //         | - bar
+}
+"#,
+        );
+    }
+    #[test]
+    fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() {
+        check_diagnostics(
+            r"
+struct S { foo: i32, bar: () }
+fn baz(s: S) -> i32 {
+    match s {
+        S { foo, .. } => foo,
+    }
+}
+",
+        )
+    }
+    #[test]
+    fn break_outside_of_loop() {
+        check_diagnostics(
+            r#"
+fn foo() { break; }
+         //^^^^^ break outside of loop
+"#,
+        );
+    }
+}
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/diagnostics/expr.rs
index d44562b22..557d01cdc 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/diagnostics/expr.rs
@@ -2,7 +2,7 @@
 use std::sync::Arc;
-use hir_def::{path::path, resolver::HasResolver, AdtId, FunctionId};
+use hir_def::{path::path, resolver::HasResolver, AdtId, DefWithBodyId};
 use hir_expand::diagnostics::DiagnosticSink;
 use ra_syntax::{ast, AstPtr};
 use rustc_hash::FxHashSet;
@@ -10,9 +10,9 @@ use rustc_hash::FxHashSet;
 use crate::{
    db::HirDatabase,
    diagnostics::{
+        match_check::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
        MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkInTailExpr, MissingPatFields,
    },
-    match_checking::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
    utils::variant_data,
    ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
@@ -30,23 +30,23 @@ pub use hir_def::{
    LocalFieldId, Lookup, VariantId,
 };
-pub struct ExprValidator<'a, 'b: 'a> {
+pub(super) struct ExprValidator<'a, 'b: 'a> {
-    func: FunctionId,
+    owner: DefWithBodyId,
    infer: Arc<InferenceResult>,
    sink: &'a mut DiagnosticSink<'b>,
 }
 impl<'a, 'b> ExprValidator<'a, 'b> {
-    pub fn new(
+    pub(super) fn new(
-        func: FunctionId,
+        owner: DefWithBodyId,
        infer: Arc<InferenceResult>,
        sink: &'a mut DiagnosticSink<'b>,
    ) -> ExprValidator<'a, 'b> {
-        ExprValidator { func, infer, sink }
+        ExprValidator { owner, infer, sink }
    }
-    pub fn validate_body(&mut self, db: &dyn HirDatabase) {
+    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let body = db.body(self.func.into());
+        let body = db.body(self.owner.into());
        for (id, expr) in body.exprs.iter() {
            if let Some((variant_def, missed_fields, true)) =
@@ -96,7 +96,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        missed_fields: Vec<LocalFieldId>,
    ) {
        // XXX: only look at source_map if we do have missing fields
-        let (_, source_map) = db.body_with_source_map(self.func.into());
+        let (_, source_map) = db.body_with_source_map(self.owner.into());
        if let Ok(source_ptr) = source_map.expr_syntax(id) {
            let root = source_ptr.file_syntax(db.upcast());
@@ -125,7 +125,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        missed_fields: Vec<LocalFieldId>,
    ) {
        // XXX: only look at source_map if we do have missing fields
-        let (_, source_map) = db.body_with_source_map(self.func.into());
+        let (_, source_map) = db.body_with_source_map(self.owner.into());
        if let Ok(source_ptr) = source_map.pat_syntax(id) {
            if let Some(expr) = source_ptr.value.as_ref().left() {
@@ -175,13 +175,17 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        };
        let sig = db.callable_item_signature(callee);
+        if sig.value.is_varargs {
+            return None;
+        }
        let params = sig.value.params();
        let mut param_count = params.len();
        let mut arg_count = args.len();
        if arg_count != param_count {
-            let (_, source_map) = db.body_with_source_map(self.func.into());
+            let (_, source_map) = db.body_with_source_map(self.owner.into());
            if let Ok(source_ptr) = source_map.expr_syntax(call_id) {
                if is_method_call {
                    param_count -= 1;
@@ -208,7 +212,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        infer: Arc<InferenceResult>,
    ) {
        let (body, source_map): (Arc<Body>, Arc<BodySourceMap>) =
-            db.body_with_source_map(self.func.into());
+            db.body_with_source_map(self.owner.into());
        let match_expr_ty = match infer.type_of_expr.get(match_expr) {
            Some(ty) => ty,
@@ -289,7 +293,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        let core_result_path = path![core::result::Result];
-        let resolver = self.func.resolver(db.upcast());
+        let resolver = self.owner.resolver(db.upcast());
        let core_result_enum = match resolver.resolve_known_enum(db.upcast(), &core_result_path) {
            Some(it) => it,
            _ => return,
@@ -304,7 +308,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        };
        if params.len() == 2 && params[0] == mismatch.actual {
-            let (_, source_map) = db.body_with_source_map(self.func.into());
+            let (_, source_map) = db.body_with_source_map(self.owner.into());
            if let Ok(source_ptr) = source_map.expr_syntax(id) {
                self.sink
@@ -376,146 +380,166 @@ pub fn record_pattern_missing_fields(
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use crate::diagnostics::tests::check_diagnostics;
-    use ra_db::fixture::WithFixture;
-    use crate::{diagnostics::MismatchedArgCount, test_db::TestDB};
-    fn check_diagnostic(ra_fixture: &str, expect: Expect) {
-        let msg = TestDB::with_single_file(ra_fixture).0.diagnostic::<MismatchedArgCount>().0;
-        expect.assert_eq(&msg);
-    }
-    fn check_no_diagnostic(ra_fixture: &str) {
-        let (s, diagnostic_count) =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MismatchedArgCount>();
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
-    }
    #[test]
    fn simple_free_fn_zero() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn zero() {}
+fn zero() {}
-            fn f() { zero(1); }
+fn f() { zero(1); }
-            ",
+       //^^^^^^^ Expected 0 arguments, found 1
-            expect![["\"zero(1)\": Expected 0 arguments, found 1\n"]],
+"#,
        );
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn zero() {}
+fn zero() {}
-            fn f() { zero(); }
+fn f() { zero(); }
-            ",
+"#,
        );
    }
    #[test]
    fn simple_free_fn_one() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn one(arg: u8) {}
+fn one(arg: u8) {}
-            fn f() { one(); }
+fn f() { one(); }
-            ",
+       //^^^^^ Expected 1 argument, found 0
-            expect![["\"one()\": Expected 1 argument, found 0\n"]],
+"#,
        );
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn one(arg: u8) {}
+fn one(arg: u8) {}
-            fn f() { one(1); }
+fn f() { one(1); }
-            ",
+"#,
        );
    }
    #[test]
    fn method_as_fn() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            struct S;
+struct S;
-            impl S {
+impl S { fn method(&self) {} }
-                fn method(&self) {}
-            }
+fn f() {
+    S::method();
-            fn f() {
+} //^^^^^^^^^^^ Expected 1 argument, found 0
-                S::method();
+"#,
-            }
-            ",
-            expect![["\"S::method()\": Expected 1 argument, found 0\n"]],
        );
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            struct S;
+struct S;
-            impl S {
+impl S { fn method(&self) {} }
-                fn method(&self) {}
-            }
-            fn f() {
+fn f() {
-                S::method(&S);
+    S::method(&S);
-                S.method();
+    S.method();
-            }
+}
-            ",
+"#,
        );
    }
    #[test]
    fn method_with_arg() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            struct S;
+struct S;
-            impl S {
+impl S { fn method(&self, arg: u8) {} }
-                fn method(&self, arg: u8) {}
-            }
            fn f() {
                S.method();
-            }
+            } //^^^^^^^^^^ Expected 1 argument, found 0
-            ",
+            "#,
-            expect![["\"S.method()\": Expected 1 argument, found 0\n"]],
        );
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            struct S;
+struct S;
-            impl S {
+impl S { fn method(&self, arg: u8) {} }
-                fn method(&self, arg: u8) {}
-            }
-            fn f() {
+fn f() {
-                S::method(&S, 0);
+    S::method(&S, 0);
-                S.method(1);
+    S.method(1);
-            }
+}
-            ",
+"#,
        );
    }
    #[test]
    fn tuple_struct() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            struct Tup(u8, u16);
+struct Tup(u8, u16);
-            fn f() {
+fn f() {
-                Tup(0);
+    Tup(0);
-            }
+} //^^^^^^ Expected 2 arguments, found 1
-            ",
+"#,
-            expect![["\"Tup(0)\": Expected 2 arguments, found 1\n"]],
        )
    }
    #[test]
    fn enum_variant() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum En {
+enum En { Variant(u8, u16), }
-                Variant(u8, u16),
+fn f() {
-            }
+    En::Variant(0);
-            fn f() {
+} //^^^^^^^^^^^^^^ Expected 2 arguments, found 1
-                En::Variant(0);
+"#,
-            }
+        )
-            ",
+    }
-            expect![["\"En::Variant(0)\": Expected 2 arguments, found 1\n"]],
+    #[test]
+    fn enum_variant_type_macro() {
+        check_diagnostics(
+            r#"
+macro_rules! Type {
+    () => { u32 };
+}
+enum Foo {
+    Bar(Type![])
+}
+impl Foo {
+    fn new() {
+        Foo::Bar(0);
+        Foo::Bar(0, 1);
+      //^^^^^^^^^^^^^^ Expected 1 argument, found 2
+        Foo::Bar();
+      //^^^^^^^^^^ Expected 1 argument, found 0
+    }
+}
+        "#,
+        );
+    }
+    #[test]
+    fn varargs() {
+        check_diagnostics(
+            r#"
+extern "C" {
+    fn fixed(fixed: u8);
+    fn varargs(fixed: u8, ...);
+    fn varargs2(...);
+}
+fn f() {
+    unsafe {
+        fixed(0);
+        fixed(0, 1);
+      //^^^^^^^^^^^ Expected 1 argument, found 2
+        varargs(0);
+        varargs(0, 1);
+        varargs2();
+        varargs2(0);
+        varargs2(0, 1);
+    }
+}
+        "#,
        )
    }
 }
diff --git a/crates/ra_hir_ty/src/match_checking.rs b/crates/ra_hir_ty/src/diagnostics/match_check.rs
index 5495ce284..507edcb7d 100644
--- a/crates/ra_hir_ty/src/match_checking.rs
+++ b/crates/ra_hir_ty/src/diagnostics/match_check.rs
@@ -41,9 +41,9 @@
 //! ```ignore
 //! // x: (Option<bool>, Result<()>)
 //! match x {
-//!     (Some(true), _) => {}
+//!     (Some(true), _) => (),
-//!     (None, Err(())) => {}
+//!     (None, Err(())) => (),
-//!     (None, Err(_)) => {}
+//!     (None, Err(_)) => (),
 //! }
 //! ```
 //!
@@ -218,15 +218,16 @@
 //!   ```
 use std::sync::Arc;
-use smallvec::{smallvec, SmallVec};
+use hir_def::{
+    adt::VariantData,
-use crate::{
+    body::Body,
-    db::HirDatabase,
+    expr::{Expr, Literal, Pat, PatId},
-    expr::{Body, Expr, Literal, Pat, PatId},
+    AdtId, EnumVariantId, VariantId,
-    ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
-use hir_def::{adt::VariantData, AdtId, EnumVariantId, VariantId};
 use ra_arena::Idx;
+use smallvec::{smallvec, SmallVec};
+use crate::{db::HirDatabase, ApplicationTy, InferenceResult, Ty, TypeCtor};
 #[derive(Debug, Clone, Copy)]
 /// Either a pattern from the source code being analyzed, represented as
@@ -271,7 +272,7 @@ impl From<&PatId> for PatIdOrWild {
 }
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum MatchCheckErr {
+pub(super) enum MatchCheckErr {
    NotImplemented,
    MalformedMatchArm,
    /// Used when type inference cannot resolve the type of
@@ -286,21 +287,21 @@ pub enum MatchCheckErr {
 ///
 /// The `std::result::Result` type is used here rather than a custom enum
 /// to allow the use of `?`.
-pub type MatchCheckResult<T> = Result<T, MatchCheckErr>;
+pub(super) type MatchCheckResult<T> = Result<T, MatchCheckErr>;
 #[derive(Debug)]
 /// A row in a Matrix.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
-pub(crate) struct PatStack(PatStackInner);
+pub(super) struct PatStack(PatStackInner);
 type PatStackInner = SmallVec<[PatIdOrWild; 2]>;
 impl PatStack {
-    pub(crate) fn from_pattern(pat_id: PatId) -> PatStack {
+    pub(super) fn from_pattern(pat_id: PatId) -> PatStack {
        Self(smallvec!(pat_id.into()))
    }
-    pub(crate) fn from_wild() -> PatStack {
+    pub(super) fn from_wild() -> PatStack {
        Self(smallvec!(PatIdOrWild::Wild))
    }
@@ -509,14 +510,14 @@ impl PatStack {
 /// A collection of PatStack.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
-pub(crate) struct Matrix(Vec<PatStack>);
+pub(super) struct Matrix(Vec<PatStack>);
 impl Matrix {
-    pub(crate) fn empty() -> Self {
+    pub(super) fn empty() -> Self {
        Self(vec![])
    }
-    pub(crate) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
+    pub(super) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
        if let Some(Pat::Or(pat_ids)) = row.get_head().map(|pat_id| pat_id.as_pat(cx)) {
            // Or patterns are expanded here
            for pat_id in pat_ids {
@@ -578,16 +579,16 @@ impl Matrix {
 /// not matched by an prior match arms.
 ///
 /// We may eventually need an `Unknown` variant here.
-pub enum Usefulness {
+pub(super) enum Usefulness {
    Useful,
    NotUseful,
 }
-pub struct MatchCheckCtx<'a> {
+pub(super) struct MatchCheckCtx<'a> {
-    pub match_expr: Idx<Expr>,
+    pub(super) match_expr: Idx<Expr>,
-    pub body: Arc<Body>,
+    pub(super) body: Arc<Body>,
-    pub infer: Arc<InferenceResult>,
+    pub(super) infer: Arc<InferenceResult>,
-    pub db: &'a dyn HirDatabase,
+    pub(super) db: &'a dyn HirDatabase,
 }
 /// Given a set of patterns `matrix`, and pattern to consider `v`, determines
@@ -598,7 +599,7 @@ pub struct MatchCheckCtx<'a> {
 /// expected that you have already type checked the match arms. All patterns in
 /// matrix should be the same type as v, as well as they should all be the same
 /// type as the match expression.
-pub(crate) fn is_useful(
+pub(super) fn is_useful(
    cx: &MatchCheckCtx,
    matrix: &Matrix,
    v: &PatStack,
@@ -836,685 +837,251 @@ fn enum_variant_matches(cx: &MatchCheckCtx, pat_id: PatId, enum_variant_id: Enum
 #[cfg(test)]
 mod tests {
-    pub(super) use insta::assert_snapshot;
+    use crate::diagnostics::tests::check_diagnostics;
-    pub(super) use ra_db::fixture::WithFixture;
-    pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
-    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
-        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
-    }
-    pub(super) fn check_diagnostic(ra_fixture: &str) {
-        let diagnostic_count =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
-        assert_eq!(1, diagnostic_count, "no diagnostic reported");
-    }
-    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
-        let (s, diagnostic_count) =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
-    }
-    #[test]
-    fn empty_tuple_no_arms_diagnostic_message() {
-        assert_snapshot!(
-            check_diagnostic_message(r"
-                fn test_fn() {
-                    match () {
-                    }
-                }
-            "),
-            @"\"()\": Missing match arm\n"
-        );
-    }
-    #[test]
-    fn empty_tuple_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match () {
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn empty_tuple_wild() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match () {
-                    _ => {}
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn empty_tuple_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match () {
-                    () => {}
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn tuple_of_empty_tuple_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (()) {
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn tuple_of_empty_tuple_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (()) {
-                    (()) => {}
-                }
-            }
-        ",
-        );
-    }
    #[test]
-    fn tuple_of_two_empty_tuple_no_arms() {
+    fn empty_tuple() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+fn main() {
-                match ((), ()) {
+    match () { }
-                }
+        //^^ Missing match arm
-            }
+   match (()) { }
-        ",
+       //^^^^ Missing match arm
-        );
-    }
-    #[test]
+    match () { _ => (), }
-    fn tuple_of_two_empty_tuple_no_diagnostic() {
+    match () { () => (), }
-        check_no_diagnostic(
+    match (()) { (()) => (), }
-            r"
+}
-            fn test_fn() {
+"#,
-                match ((), ()) {
-                    ((), ()) => {}
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn bool_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match false {
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn bool_missing_arm() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match false {
-                    true => {}
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn bool_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match false {
-                    true => {}
-                    false => {}
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn tuple_of_bools_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn tuple_of_bools_missing_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (true, true) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn tuple_of_bools_missing_arm() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (false, true) => {},
-                    (false, false) => {},
-                    (true, false) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn tuple_of_bools_with_wilds() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (false, _) => {},
-                    (true, false) => {},
-                    (_, true) => {},
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn tuple_of_bools_no_diagnostic() {
+    fn tuple_of_two_empty_tuple() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+fn main() {
-                match (false, true) {
+    match ((), ()) { }
-                    (true, true) => {},
+        //^^^^^^^^ Missing match arm
-                    (true, false) => {},
-                    (false, true) => {},
-                    (false, false) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+    match ((), ()) { ((), ()) => (), }
-    fn tuple_of_bools_binding_missing_arms() {
+}
-        check_diagnostic(
+"#,
-            r"
+        );
-            fn test_fn() {
+    }
-                match (false, true) {
-                    (true, _x) => {},
+    #[test]
-                }
+    fn boolean() {
-            }
+        check_diagnostics(
-        ",
+            r#"
-        );
+fn test_main() {
-    }
+    match false { }
+        //^^^^^ Missing match arm
-    #[test]
+    match false { true => (), }
-    fn tuple_of_bools_binding_no_diagnostic() {
+        //^^^^^ Missing match arm
-        check_no_diagnostic(
+    match (false, true) {}
-            r"
+        //^^^^^^^^^^^^^ Missing match arm
-            fn test_fn() {
+    match (false, true) { (true, true) => (), }
-                match (false, true) {
+        //^^^^^^^^^^^^^ Missing match arm
-                    (true, _x) => {},
+    match (false, true) {
-                    (false, true) => {},
+        //^^^^^^^^^^^^^ Missing match arm
-                    (false, false) => {},
+        (false, true) => (),
-                }
+        (false, false) => (),
-            }
+        (true, false) => (),
-        ",
+    }
+    match (false, true) { (true, _x) => (), }
+        //^^^^^^^^^^^^^ Missing match arm
+    match false { true => (), false => (), }
+    match (false, true) {
+        (false, _) => (),
+        (true, false) => (),
+        (_, true) => (),
+    }
+    match (false, true) {
+        (true, true) => (),
+        (true, false) => (),
+        (false, true) => (),
+        (false, false) => (),
+    }
+    match (false, true) {
+        (true, _x) => (),
+        (false, true) => (),
+        (false, false) => (),
+    }
+    match (false, true, false) {
+        (false, ..) => (),
+        (true, ..) => (),
+    }
+    match (false, true, false) {
+        (.., false) => (),
+        (.., true) => (),
+    }
+    match (false, true, false) { (..) => (), }
+}
+"#,
        );
    }
    #[test]
-    fn tuple_of_bools_with_ellipsis_at_end_no_diagnostic() {
+    fn tuple_of_tuple_and_bools() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+fn main() {
-                match (false, true, false) {
+    match (false, ((), false)) {}
-                    (false, ..) => {},
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-                    (true, ..) => {},
+    match (false, ((), false)) { (true, ((), true)) => (), }
-                }
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-            }
+    match (false, ((), false)) { (true, _) => (), }
-        ",
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-        );
-    }
-    #[test]
+    match (false, ((), false)) {
-    fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
+        (true, ((), true)) => (),
-        check_no_diagnostic(
+        (true, ((), false)) => (),
-            r"
+        (false, ((), true)) => (),
-            fn test_fn() {
+        (false, ((), false)) => (),
-                match (false, true, false) {
-                    (.., false) => {},
-                    (.., true) => {},
-                }
-            }
-        ",
-        );
    }
+    match (false, ((), false)) {
-    #[test]
+        (true, ((), true)) => (),
-    fn tuple_of_bools_with_ellipsis_no_diagnostic() {
+        (true, ((), false)) => (),
-        check_no_diagnostic(
+        (false, _) => (),
-            r"
-            fn test_fn() {
-                match (false, true, false) {
-                    (..) => {},
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn tuple_of_tuple_and_bools_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn tuple_of_tuple_and_bools_missing_arms() {
+    fn enums() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+enum Either { A, B, }
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn tuple_of_tuple_and_bools_no_diagnostic() {
+    match Either::A { }
-        check_no_diagnostic(
+        //^^^^^^^^^ Missing match arm
-            r"
+    match Either::B { Either::A => (), }
-            fn test_fn() {
+        //^^^^^^^^^ Missing match arm
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                    (true, ((), false)) => {},
-                    (false, ((), true)) => {},
-                    (false, ((), false)) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+    match &Either::B {
-    fn tuple_of_tuple_and_bools_wildcard_missing_arms() {
+        //^^^^^^^^^^ Missing match arm
-        check_diagnostic(
+        Either::A => (),
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, _) => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match Either::B {
-    fn tuple_of_tuple_and_bools_wildcard_no_diagnostic() {
+        Either::A => (), Either::B => (),
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                    (true, ((), false)) => {},
-                    (false, _) => {},
-                }
-            }
-        ",
-        );
    }
+    match &Either::B {
-    #[test]
+        Either::A => (), Either::B => (),
-    fn enum_no_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::A {
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn enum_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A => {},
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn enum_no_diagnostic() {
+    fn enum_containing_bool() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A(bool), B }
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_ref_missing_arms() {
+    match Either::B { }
-        check_diagnostic(
+        //^^^^^^^^^ Missing match arm
-            r"
+    match Either::B {
-            enum Either {
+        //^^^^^^^^^ Missing match arm
-                A,
+        Either::A(true) => (), Either::B => ()
-                B,
-            }
-            fn test_fn() {
-                match &Either::B {
-                    Either::A => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match Either::B {
-    fn enum_ref_no_diagnostic() {
+        Either::A(true) => (),
-        check_no_diagnostic(
+        Either::A(false) => (),
-            r"
+        Either::B => (),
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match &Either::B {
-                    Either::A => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
    }
+    match Either::B {
-    #[test]
+        Either::B => (),
-    fn enum_containing_bool_no_arms() {
+        _ => (),
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                }
-            }
-        ",
-        );
    }
+    match Either::B {
-    #[test]
+        Either::A(_) => (),
-    fn enum_containing_bool_missing_arms() {
+        Either::B => (),
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true) => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+}
-    fn enum_containing_bool_no_diagnostic() {
+        "#,
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true) => (),
-                    Either::A(false) => (),
-                    Either::B => (),
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn enum_containing_bool_with_wild_no_diagnostic() {
+    fn enum_different_sizes() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A(bool), B(bool, bool) }
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::B => (),
-                    _ => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_containing_bool_with_wild_2_no_diagnostic() {
+    match Either::A(false) {
-        check_no_diagnostic(
+        //^^^^^^^^^^^^^^^^ Missing match arm
-            r"
+        Either::A(_) => (),
-            enum Either {
+        Either::B(false, _) => (),
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(_) => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match Either::A(false) {
-    fn enum_different_sizes_missing_arms() {
+        Either::A(_) => (),
-        check_diagnostic(
+        Either::B(true, _) => (),
-            r"
+        Either::B(false, _) => (),
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(_) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
-        );
    }
+    match Either::A(false) {
-    #[test]
+        Either::A(true) | Either::A(false) => (),
-    fn enum_different_sizes_no_diagnostic() {
+        Either::B(true, _) => (),
-        check_no_diagnostic(
+        Either::B(false, _) => (),
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(_) => (),
-                    Either::B(true, _) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn or_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(true) | Either::A(false) => (),
-                    Either::B(true, _) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
        );
    }
    #[test]
    fn tuple_of_enum_no_diagnostic() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A(bool), B(bool, bool) }
-                A(bool),
+enum Either2 { C, D }
-                B(bool, bool),
-            }
+fn main() {
-            enum Either2 {
+    match (Either::A(false), Either2::C) {
-                C,
+        (Either::A(true), _) | (Either::A(false), _) => (),
-                D,
+        (Either::B(true, _), Either2::C) => (),
-            }
+        (Either::B(false, _), Either2::C) => (),
-            fn test_fn() {
+        (Either::B(_, _), Either2::D) => (),
-                match (Either::A(false), Either2::C) {
-                    (Either::A(true), _) | (Either::A(false), _) => (),
-                    (Either::B(true, _), Either2::C) => (),
-                    (Either::B(false, _), Either2::C) => (),
-                    (Either::B(_, _), Either2::D) => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn mismatched_types() {
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            enum Either2 {
-                C,
-                D,
-            }
-            fn test_fn() {
-                match Either::A {
-                    Either2::C => (),
-                    Either2::D => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn mismatched_types_with_different_arity() {
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (true, false) {
-                    (true, false, true) => (),
-                    (true) => (),
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn malformed_match_arm_tuple_missing_pattern() {
+    fn mismatched_types() {
        // Match statements with arms that don't match the
        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+enum Either { A, B }
-                match (0) {
+enum Either2 { C, D }
-                    () => (),
-                }
+fn main() {
-            }
+    match Either::A {
-        ",
+        Either2::C => (),
+        Either2::D => (),
+    }
+    match (true, false) {
+        (true, false, true) => (),
+        (true) => (),
+    }
+    match (0) { () => () }
+    match Unresolved::Bar { Unresolved::Baz => () }
+}
+        "#,
        );
    }
@@ -1522,636 +1089,333 @@ mod tests {
    fn malformed_match_arm_tuple_enum_missing_pattern() {
        // We are testing to be sure we don't panic here when the match
        // arm `Either::B` is missing its pattern.
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A, B(u32) }
-                A,
-                B(u32),
-            }
-            fn test_fn() {
-                match Either::A {
-                    Either::A => (),
-                    Either::B() => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_not_in_scope() {
+    match Either::A {
-        // The enum is not in scope so we don't perform exhaustiveness
+        Either::A => (),
-        // checking, but we want to be sure we don't panic here (and
+        Either::B() => (),
-        // we don't create a diagnostic).
+    }
-        check_no_diagnostic(
+}
-            r"
+"#,
-            fn test_fn() {
-                match Foo::Bar {
-                    Foo::Baz => (),
-                }
-            }
-        ",
        );
    }
    #[test]
    fn expr_diverges() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A, B }
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn expr_loop_with_break() {
+    match loop {} {
-        check_no_diagnostic(
+        Either::A => (),
-            r"
+        Either::B => (),
-            enum Either {
+    }
-                A,
+    match loop {} {
-                B,
+        Either::A => (),
-            }
+    }
-            fn test_fn() {
+    match loop { break Foo::A } {
-                match loop { break Foo::A } {
+        //^^^^^^^^^^^^^^^^^^^^^ Missing match arm
-                    Either::A => (),
+        Either::A => (),
-                    Either::B => (),
+    }
-                }
+    match loop { break Foo::A } {
-            }
+        Either::A => (),
-        ",
+        Either::B => (),
+    }
+}
+"#,
        );
    }
    #[test]
    fn expr_partially_diverges() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either<T> {
+enum Either<T> { A(T), B }
-                A(T),
-                B,
-            }
-            fn foo() -> Either<!> {
-                Either::B
-            }
-            fn test_fn() -> u32 {
-                match foo() {
-                    Either::A(val) => val,
-                    Either::B => 0,
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn foo() -> Either<!> { Either::B }
-    fn enum_record_no_arms() {
+fn main() -> u32 {
-        check_diagnostic(
+    match foo() {
-            r"
+        Either::A(val) => val,
-            enum Either {
+        Either::B => 0,
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn enum_record_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: true } => (),
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn enum_record_no_diagnostic() {
+    fn enum_record() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A { foo: bool }, B }
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: true } => (),
-                    Either::A { foo: false } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_record_missing_field_no_diagnostic() {
+    let a = Either::A { foo: true };
-        // When `Either::A` is missing a struct member, we don't want
+    match a { }
-        // to fire the missing match arm diagnostic. This should fire
+        //^ Missing match arm
-        // some other diagnostic.
+    match a { Either::A { foo: true } => () }
-        check_no_diagnostic(
+        //^ Missing match arm
-            r"
+    match a {
-            enum Either {
+        Either::A { } => (),
-                A { foo: bool },
+                //^^^ Missing structure fields:
-                B,
+                //  | - foo
-            }
+        Either::B => (),
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
+    match a {
+        //^ Missing match arm
+        Either::A { } => (),
+    }           //^^^ Missing structure fields:
+                //  | - foo
-    #[test]
+    match a {
-    fn enum_record_missing_field_missing_match_arm() {
+        Either::A { foo: true } => (),
-        // Even though `Either::A` is missing fields, we still want to fire
+        Either::A { foo: false } => (),
-        // the missing arm diagnostic here, since we know `Either::B` is missing.
+        Either::B => (),
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { } => (),
-                }
-            }
-        ",
-        );
    }
+    match a {
-    #[test]
+        Either::A { foo: _ } => (),
-    fn enum_record_no_diagnostic_wild() {
+        Either::B => (),
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: _ } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn enum_record_fields_out_of_order_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: () },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { bar: (), foo: false } => (),
-                    Either::A { foo: true, bar: () } => (),
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn enum_record_fields_out_of_order_no_diagnostic() {
+    fn enum_record_fields_out_of_order() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either {
-                A { foo: bool, bar: () },
+    A { foo: bool, bar: () },
-                B,
+    B,
-            }
+}
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { bar: (), foo: false } => (),
-                    Either::A { foo: true, bar: () } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_record_ellipsis_missing_arm() {
+    let a = Either::A { foo: true, bar: () };
-        check_diagnostic(
+    match a {
-            r"
+        //^ Missing match arm
-            enum Either {
+        Either::A { bar: (), foo: false } => (),
-                A { foo: bool, bar: bool },
+        Either::A { foo: true, bar: () } => (),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A { foo: true, .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match a {
-    fn enum_record_ellipsis_no_diagnostic() {
+        Either::A { bar: (), foo: false } => (),
-        check_no_diagnostic(
+        Either::A { foo: true, bar: () } => (),
-            r"
+        Either::B => (),
-            enum Either {
-                A { foo: bool, bar: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: true, .. } => (),
-                    Either::A { foo: false, .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn enum_record_ellipsis_all_fields_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { .. } => (),
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn enum_record_ellipsis_all_fields_no_diagnostic() {
+    fn enum_record_ellipsis() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either {
-                A { foo: bool, bar: bool },
+    A { foo: bool, bar: bool },
-                B,
+    B,
-            }
+}
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_tuple_partial_ellipsis_no_diagnostic() {
+    let a = Either::B;
-        check_no_diagnostic(
+    match a {
-            r"
+        //^ Missing match arm
-            enum Either {
+        Either::A { foo: true, .. } => (),
-                A(bool, bool, bool, bool),
+        Either::B => (),
-                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 => {},
-                }
-            }
-        ",
-        );
    }
+    match a {
-    #[test]
+        //^ Missing match arm
-    fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
+        Either::A { .. } => (),
-        check_no_diagnostic(
-            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 => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match a {
-    fn enum_tuple_partial_ellipsis_missing_arm() {
+        Either::A { foo: true, .. } => (),
-        check_diagnostic(
+        Either::A { foo: false, .. } => (),
-            r"
+        Either::B => (),
-            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 => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match a {
-    fn enum_tuple_partial_ellipsis_2_missing_arm() {
+        Either::A { .. } => (),
-        check_diagnostic(
+        Either::B => (),
-            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 => {},
-                }
-            }
-        ",
-        );
    }
+}
-    #[test]
+"#,
-    fn enum_tuple_ellipsis_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool, bool, bool, bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(..) => {},
-                    Either::B => {},
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn enum_never() {
+    fn enum_tuple_partial_ellipsis() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Never {}
+enum Either {
+    A(bool, bool, bool, bool),
+    B,
+}
-            fn test_fn(never: Never) {
+fn main() {
-                match never {}
+    match Either::B {
-            }
+        //^^^^^^^^^ Missing match arm
-        ",
+        Either::A(true, .., true) => (),
-        );
+        Either::A(true, .., false) => (),
+        Either::A(false, .., false) => (),
+        Either::B => (),
+    }
+    match Either::B {
+        //^^^^^^^^^ Missing match arm
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(.., true) => (),
+        Either::B => (),
+    }
+    match Either::B {
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(false, .., true) => (),
+        Either::A(false, .., false) => (),
+        Either::B => (),
+    }
+    match Either::B {
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(.., true) => (),
+        Either::A(.., false) => (),
+        Either::B => (),
    }
+}
-    #[test]
+"#,
-    fn type_never() {
-        check_no_diagnostic(
-            r"
-            fn test_fn(never: !) {
-                match never {}
-            }
-        ",
        );
    }
    #[test]
-    fn enum_never_ref() {
+    fn never() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Never {}
+enum Never {}
-            fn test_fn(never: &Never) {
+fn enum_(never: Never) {
-                match never {}
+    match never {}
-            }
+}
-        ",
+fn enum_ref(never: &Never) {
-        );
+    match never {}
-    }
+}
+fn bang(never: !) {
-    #[test]
+    match never {}
-    fn expr_diverges_missing_arm() {
+}
-        check_no_diagnostic(
+"#,
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                }
-            }
-        ",
        );
    }
    #[test]
    fn or_pattern_panic() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            pub enum Category {
+pub enum Category { Infinity, Zero }
-                Infinity,
-                Zero,
-            }
-            fn panic(a: Category, b: Category) {
+fn panic(a: Category, b: Category) {
-                match (a, b) {
+    match (a, b) {
-                    (Category::Zero | Category::Infinity, _) => {}
+        (Category::Zero | Category::Infinity, _) => (),
-                    (_, Category::Zero | Category::Infinity) => {}
+        (_, Category::Zero | Category::Infinity) => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
-    fn or_pattern_panic_2() {
+    // so this acts as a regression test for that.
-        // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
+    match (a, b) {
-        // so this acts as a regression test for that.
+        //^^^^^^ Missing match arm
-        check_diagnostic(
+        (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => (),
-            r"
+        (Category::Infinity | Category::Zero, _) => (),
-            pub enum Category {
-                Infinity,
-                Zero,
-            }
-            fn panic(a: Category, b: Category) {
-                match (a, b) {
-                    (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => {}
-                    (Category::Infinity | Category::Zero, _) => {}
-                }
-            }
-        ",
-        );
    }
 }
+"#,
-#[cfg(test)]
+        );
-mod false_negatives {
+    }
-    //! The implementation of match checking here is a work in progress. As we roll this out, we
-    //! prefer false negatives to false positives (ideally there would be no false positives). This
+    mod false_negatives {
-    //! test module should document known false negatives. Eventually we will have a complete
+        //! The implementation of match checking here is a work in progress. As we roll this out, we
-    //! implementation of match checking and this module will be empty.
+        //! prefer false negatives to false positives (ideally there would be no false positives). This
-    //!
+        //! test module should document known false negatives. Eventually we will have a complete
-    //! The reasons for documenting known false negatives:
+        //! implementation of match checking and this module will be empty.
-    //!
+        //!
-    //!   1. It acts as a backlog of work that can be done to improve the behavior of the system.
+        //! The reasons for documenting known false negatives:
-    //!   2. It ensures the code doesn't panic when handling these cases.
+        //!
+        //!   1. It acts as a backlog of work that can be done to improve the behavior of the system.
-    use super::tests::*;
+        //!   2. It ensures the code doesn't panic when handling these cases.
+        use super::*;
-    #[test]
-    fn integers() {
+        #[test]
-        // This is a false negative.
+        fn integers() {
-        // We don't currently check integer exhaustiveness.
+            // We don't currently check integer exhaustiveness.
-        check_no_diagnostic(
+            check_diagnostics(
-            r"
+                r#"
-            fn test_fn() {
+fn main() {
-                match 5 {
+    match 5 {
-                    10 => (),
+        10 => (),
-                    11..20 => (),
+        11..20 => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
-    fn internal_or() {
-        // This is a false negative.
-        // We do not currently handle patterns with internal `or`s.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                enum Either {
-                    A(bool),
-                    B,
-                }
-                match Either::B {
-                    Either::A(true | false) => (),
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn expr_loop_missing_arm() {
+        fn internal_or() {
-        // This is a false negative.
+            // We do not currently handle patterns with internal `or`s.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+            check_diagnostics(
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
+                r#"
-        // with `!`.
+fn main() {
-        check_diagnostic(
+    enum Either { A(bool), B }
-            r"
+    match Either::B {
-            enum Either {
+        Either::A(true | false) => (),
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop { break Foo::A } {
-                    Either::A => (),
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+        fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        // This is a false negative.
+            // We don't currently handle tuple patterns with ellipsis.
-        // We don't currently handle tuple patterns with ellipsis.
+            check_diagnostics(
-        check_no_diagnostic(
+                r#"
-            r"
+fn main() {
-            fn test_fn() {
+    match (false, true, false) {
-                match (false, true, false) {
+        (false, ..) => (),
-                    (false, ..) => {},
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+        fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        // This is a false negative.
+            // We don't currently handle tuple patterns with ellipsis.
-        // We don't currently handle tuple patterns with ellipsis.
+            check_diagnostics(
-        check_no_diagnostic(
+                r#"
-            r"
+fn main() {
-            fn test_fn() {
+    match (false, true, false) {
-                match (false, true, false) {
+        (.., false) => (),
-                    (.., false) => {},
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn struct_missing_arm() {
+        fn struct_missing_arm() {
-        // This is a false negative.
+            // We don't currently handle structs.
-        // We don't currently handle structs.
+            check_diagnostics(
-        check_no_diagnostic(
+                r#"
-            r"
+struct Foo { a: bool }
-            struct Foo {
+fn main(f: Foo) {
-                a: bool,
+    match f { Foo { a: true } => () }
-            }
+}
-            fn test_fn(f: Foo) {
+"#,
-                match f {
+            );
-                    Foo { a: true } => {},
+        }
-                }
-            }
-        ",
-        );
    }
 }
diff --git a/crates/ra_hir_ty/src/unsafe_validation.rs b/crates/ra_hir_ty/src/diagnostics/unsafe_check.rs
index c512c4f8e..9e4ed9a8b 100644
--- a/crates/ra_hir_ty/src/unsafe_validation.rs
+++ b/crates/ra_hir_ty/src/diagnostics/unsafe_check.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use hir_def::{
    body::Body,
    expr::{Expr, ExprId, UnaryOp},
-    DefWithBodyId, FunctionId,
+    DefWithBodyId,
 };
 use hir_expand::diagnostics::DiagnosticSink;
@@ -15,26 +15,29 @@ use crate::{
    InferenceResult, Ty, TypeCtor,
 };
-pub struct UnsafeValidator<'a, 'b: 'a> {
+pub(super) struct UnsafeValidator<'a, 'b: 'a> {
-    func: FunctionId,
+    owner: DefWithBodyId,
    infer: Arc<InferenceResult>,
    sink: &'a mut DiagnosticSink<'b>,
 }
 impl<'a, 'b> UnsafeValidator<'a, 'b> {
-    pub fn new(
+    pub(super) fn new(
-        func: FunctionId,
+        owner: DefWithBodyId,
        infer: Arc<InferenceResult>,
        sink: &'a mut DiagnosticSink<'b>,
    ) -> UnsafeValidator<'a, 'b> {
-        UnsafeValidator { func, infer, sink }
+        UnsafeValidator { owner, infer, sink }
    }
-    pub fn validate_body(&mut self, db: &dyn HirDatabase) {
+    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let def = self.func.into();
+        let def = self.owner.into();
        let unsafe_expressions = unsafe_expressions(db, self.infer.as_ref(), def);
-        let func_data = db.function_data(self.func);
+        let is_unsafe = match self.owner {
-        if func_data.is_unsafe
+            DefWithBodyId::FunctionId(it) => db.function_data(it).is_unsafe,
+            DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_) => false,
+        };
+        if is_unsafe
            || unsafe_expressions
                .iter()
                .filter(|unsafe_expr| !unsafe_expr.inside_unsafe_block)
@@ -118,3 +121,53 @@ fn walk_unsafe(
        walk_unsafe(unsafe_exprs, db, infer, body, child, inside_unsafe_block);
    });
 }
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::check_diagnostics;
+    #[test]
+    fn missing_unsafe_diagnostic_with_raw_ptr() {
+        check_diagnostics(
+            r#"
+fn main() {
+    let x = &5 as *const usize;
+    unsafe { let y = *x; }
+    let z = *x;
+}         //^^ This operation is unsafe and requires an unsafe function or block
+"#,
+        )
+    }
+    #[test]
+    fn missing_unsafe_diagnostic_with_unsafe_call() {
+        check_diagnostics(
+            r#"
+struct HasUnsafe;
+impl HasUnsafe {
+    unsafe fn unsafe_fn(&self) {
+        let x = &5 as *const usize;
+        let y = *x;
+    }
+}
+unsafe fn unsafe_fn() {
+    let x = &5 as *const usize;
+    let y = *x;
+}
+fn main() {
+    unsafe_fn();
+  //^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
+    HasUnsafe.unsafe_fn();
+  //^^^^^^^^^^^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
+    unsafe {
+        unsafe_fn();
+        HasUnsafe.unsafe_fn();
+    }
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index ac68c5661..c860c254c 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -243,10 +243,17 @@ impl HirDisplay for ApplicationTy {
                    write!(f, ")")?;
                }
            }
-            TypeCtor::FnPtr { .. } => {
+            TypeCtor::FnPtr { is_varargs, .. } => {
-                let sig = FnSig::from_fn_ptr_substs(&self.parameters);
+                let sig = FnSig::from_fn_ptr_substs(&self.parameters, is_varargs);
                write!(f, "fn(")?;
                f.write_joined(sig.params(), ", ")?;
+                if is_varargs {
+                    if sig.params().is_empty() {
+                        write!(f, "...")?;
+                    } else {
+                        write!(f, ", ...")?;
+                    }
+                }
                write!(f, ")")?;
                let ret = sig.ret();
                if *ret != Ty::unit() {
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 2ce4f65cc..28f32a0a4 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -168,7 +168,7 @@ impl InferenceResult {
    pub fn add_diagnostics(
        &self,
        db: &dyn HirDatabase,
-        owner: FunctionId,
+        owner: DefWithBodyId,
        sink: &mut DiagnosticSink,
    ) {
        self.diagnostics.iter().for_each(|it| it.add_to(db, owner, sink))
@@ -760,7 +760,7 @@ impl std::ops::BitOrAssign for Diverges {
 }
 mod diagnostics {
-    use hir_def::{expr::ExprId, FunctionId};
+    use hir_def::{expr::ExprId, DefWithBodyId};
    use hir_expand::diagnostics::DiagnosticSink;
    use crate::{
@@ -778,17 +778,17 @@ mod diagnostics {
        pub(super) fn add_to(
            &self,
            db: &dyn HirDatabase,
-            owner: FunctionId,
+            owner: DefWithBodyId,
            sink: &mut DiagnosticSink,
        ) {
            match self {
                InferenceDiagnostic::NoSuchField { expr, field } => {
-                    let (_, source_map) = db.body_with_source_map(owner.into());
+                    let (_, source_map) = db.body_with_source_map(owner);
                    let field = source_map.field_syntax(*expr, *field);
                    sink.push(NoSuchField { file: field.file_id, field: field.value })
                }
                InferenceDiagnostic::BreakOutsideOfLoop { expr } => {
-                    let (_, source_map) = db.body_with_source_map(owner.into());
+                    let (_, source_map) = db.body_with_source_map(owner);
                    let ptr = source_map
                        .expr_syntax(*expr)
                        .expect("break outside of loop in synthetic syntax");
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index bd9a387f5..ab586b018 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -220,7 +220,7 @@ impl<'a> InferenceContext<'a> {
                };
                sig_tys.push(ret_ty.clone());
                let sig_ty = Ty::apply(
-                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
+                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1, is_varargs: false },
                    Substs(sig_tys.clone().into()),
                );
                let closure_ty =
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 2652d200f..c4c24a83b 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -12,15 +12,12 @@ pub mod traits;
 pub mod method_resolution;
 mod op;
 mod lower;
-mod match_checking;
 pub(crate) mod infer;
 pub(crate) mod utils;
 pub mod display;
 pub mod db;
 pub mod diagnostics;
-pub mod expr;
-pub mod unsafe_validation;
 #[cfg(test)]
 mod tests;
@@ -115,7 +112,7 @@ pub enum TypeCtor {
    /// fn foo() -> i32 { 1 }
    /// let bar: fn() -> i32 = foo;
    /// ```
-    FnPtr { num_args: u16 },
+    FnPtr { num_args: u16, is_varargs: bool },
    /// The never type `!`.
    Never,
@@ -190,7 +187,7 @@ impl TypeCtor {
                    }
                }
            }
-            TypeCtor::FnPtr { num_args } => num_args as usize + 1,
+            TypeCtor::FnPtr { num_args, is_varargs: _ } => num_args as usize + 1,
            TypeCtor::Tuple { cardinality } => cardinality as usize,
        }
    }
@@ -670,19 +667,20 @@ pub enum TyKind {
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct FnSig {
    params_and_return: Arc<[Ty]>,
+    is_varargs: bool,
 }
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<FnSig>;
 impl FnSig {
-    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty) -> FnSig {
+    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty, is_varargs: bool) -> FnSig {
        params.push(ret);
-        FnSig { params_and_return: params.into() }
+        FnSig { params_and_return: params.into(), is_varargs }
    }
-    pub fn from_fn_ptr_substs(substs: &Substs) -> FnSig {
+    pub fn from_fn_ptr_substs(substs: &Substs, is_varargs: bool) -> FnSig {
-        FnSig { params_and_return: Arc::clone(&substs.0) }
+        FnSig { params_and_return: Arc::clone(&substs.0), is_varargs }
    }
    pub fn params(&self) -> &[Ty] {
@@ -727,7 +725,7 @@ impl Ty {
    }
    pub fn fn_ptr(sig: FnSig) -> Self {
        Ty::apply(
-            TypeCtor::FnPtr { num_args: sig.params().len() as u16 },
+            TypeCtor::FnPtr { num_args: sig.params().len() as u16, is_varargs: sig.is_varargs },
            Substs(sig.params_and_return),
        )
    }
@@ -824,7 +822,9 @@ impl Ty {
    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<FnSig> {
        match self {
            Ty::Apply(a_ty) => match a_ty.ctor {
-                TypeCtor::FnPtr { .. } => Some(FnSig::from_fn_ptr_substs(&a_ty.parameters)),
+                TypeCtor::FnPtr { is_varargs, .. } => {
+                    Some(FnSig::from_fn_ptr_substs(&a_ty.parameters, is_varargs))
+                }
                TypeCtor::FnDef(def) => {
                    let sig = db.callable_item_signature(def);
                    Some(sig.subst(&a_ty.parameters))
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 101b8aebe..6f4398e84 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -176,9 +176,12 @@ impl Ty {
                Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
            }
            TypeRef::Placeholder => Ty::Unknown,
-            TypeRef::Fn(params) => {
+            TypeRef::Fn(params, is_varargs) => {
                let sig = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
-                Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
+                Ty::apply(
+                    TypeCtor::FnPtr { num_args: sig.len() as u16 - 1, is_varargs: *is_varargs },
+                    sig,
+                )
            }
            TypeRef::DynTrait(bounds) => {
                let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
@@ -996,7 +999,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
    let ret = Ty::from_hir(&ctx_ret, &data.ret_type);
    let generics = generics(db.upcast(), def.into());
    let num_binders = generics.len();
-    Binders::new(num_binders, FnSig::from_params_and_return(params, ret))
+    Binders::new(num_binders, FnSig::from_params_and_return(params, ret, data.is_varargs))
 }
 /// Build the declared type of a function. This should not need to look at the
@@ -1047,7 +1050,7 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS
    let params =
        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.into());
-    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value, false))
 }
 /// Build the type of a tuple struct constructor.
@@ -1071,7 +1074,7 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId)
    let params =
        fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
    let ret = type_for_adt(db, def.parent.into());
-    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value, false))
 }
 /// Build the type of a tuple enum variant constructor.
diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index dc447955f..a1714ff0f 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -5,19 +5,13 @@ use std::{
    sync::{Arc, Mutex},
 };
-use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId, ModuleId};
+use hir_def::{db::DefDatabase, ModuleId};
-use hir_expand::{db::AstDatabase, diagnostics::DiagnosticSink};
+use hir_expand::db::AstDatabase;
 use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase, Upcast};
 use ra_syntax::TextRange;
 use rustc_hash::{FxHashMap, FxHashSet};
-use stdx::format_to;
 use test_utils::extract_annotations;
-use crate::{
-    db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator,
-    unsafe_validation::UnsafeValidator,
-};
 #[salsa::database(
    ra_db::SourceDatabaseExtStorage,
    ra_db::SourceDatabaseStorage,
@@ -82,7 +76,7 @@ impl FileLoader for TestDB {
 }
 impl TestDB {
-    pub fn module_for_file(&self, file_id: FileId) -> ModuleId {
+    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
        for &krate in self.relevant_crates(file_id).iter() {
            let crate_def_map = self.crate_def_map(krate);
            for (local_id, data) in crate_def_map.modules.iter() {
@@ -94,67 +88,7 @@ impl TestDB {
        panic!("Can't find module for file")
    }
-    fn diag<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+    pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
-        let crate_graph = self.crate_graph();
-        for krate in crate_graph.iter() {
-            let crate_def_map = self.crate_def_map(krate);
-            let mut fns = Vec::new();
-            for (module_id, _) in crate_def_map.modules.iter() {
-                for decl in crate_def_map[module_id].scope.declarations() {
-                    if let ModuleDefId::FunctionId(f) = decl {
-                        fns.push(f)
-                    }
-                }
-                for impl_id in crate_def_map[module_id].scope.impls() {
-                    let impl_data = self.impl_data(impl_id);
-                    for item in impl_data.items.iter() {
-                        if let AssocItemId::FunctionId(f) = item {
-                            fns.push(*f)
-                        }
-                    }
-                }
-            }
-            for f in fns {
-                let infer = self.infer(f.into());
-                let mut sink = DiagnosticSink::new(&mut cb);
-                infer.add_diagnostics(self, f, &mut sink);
-                let mut validator = ExprValidator::new(f, infer.clone(), &mut sink);
-                validator.validate_body(self);
-                let mut validator = UnsafeValidator::new(f, infer, &mut sink);
-                validator.validate_body(self);
-            }
-        }
-    }
-    pub fn diagnostics(&self) -> (String, u32) {
-        let mut buf = String::new();
-        let mut count = 0;
-        self.diag(|d| {
-            format_to!(buf, "{:?}: {}\n", d.syntax_node(self).text(), d.message());
-            count += 1;
-        });
-        (buf, count)
-    }
-    /// Like `diagnostics`, but filtered for a single diagnostic.
-    pub fn diagnostic<D: Diagnostic>(&self) -> (String, u32) {
-        let mut buf = String::new();
-        let mut count = 0;
-        self.diag(|d| {
-            // We want to filter diagnostics by the particular one we are testing for, to
-            // avoid surprising results in tests.
-            if d.downcast_ref::<D>().is_some() {
-                format_to!(buf, "{:?}: {}\n", d.syntax_node(self).text(), d.message());
-                count += 1;
-            };
-        });
-        (buf, count)
-    }
-    pub fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
        let mut files = Vec::new();
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 27f5a60bf..d57b3f288 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -20,7 +20,6 @@ use hir_def::{
    AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
 };
 use hir_expand::{db::AstDatabase, InFile};
-use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt};
 use ra_syntax::{
    algo,
@@ -341,410 +340,3 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
    }
 }
-#[test]
-fn no_such_field_diagnostics() {
-    let diagnostics = TestDB::with_files(
-        r"
-        //- /lib.rs
-        struct S { foo: i32, bar: () }
-        impl S {
-            fn new() -> S {
-                S {
-                    foo: 92,
-                    baz: 62,
-                }
-            }
-        }
-        ",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###"
-    "baz: 62": no such field
-    "{\n            foo: 92,\n            baz: 62,\n        }": Missing structure fields:
-    - bar
-    "###
-    );
-}
-#[test]
-fn no_such_field_with_feature_flag_diagnostics() {
-    let diagnostics = TestDB::with_files(
-        r#"
-        //- /lib.rs crate:foo cfg:feature=foo
-        struct MyStruct {
-            my_val: usize,
-            #[cfg(feature = "foo")]
-            bar: bool,
-        }
-        impl MyStruct {
-            #[cfg(feature = "foo")]
-            pub(crate) fn new(my_val: usize, bar: bool) -> Self {
-                Self { my_val, bar }
-            }
-            #[cfg(not(feature = "foo"))]
-            pub(crate) fn new(my_val: usize, _bar: bool) -> Self {
-                Self { my_val }
-            }
-        }
-        "#,
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""###);
-}
-#[test]
-fn no_such_field_enum_with_feature_flag_diagnostics() {
-    let diagnostics = TestDB::with_files(
-        r#"
-        //- /lib.rs crate:foo cfg:feature=foo
-        enum Foo {
-            #[cfg(not(feature = "foo"))]
-            Buz,
-            #[cfg(feature = "foo")]
-            Bar,
-            Baz
-        }
-        fn test_fn(f: Foo) {
-            match f {
-                Foo::Bar => {},
-                Foo::Baz => {},
-            }
-        }
-        "#,
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""###);
-}
-#[test]
-fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
-    let diagnostics = TestDB::with_files(
-        r#"
-        //- /lib.rs crate:foo cfg:feature=foo
-        struct S {
-            #[cfg(feature = "foo")]
-            foo: u32,
-            #[cfg(not(feature = "foo"))]
-            bar: u32,
-        }
-        impl S {
-            #[cfg(feature = "foo")]
-            fn new(foo: u32) -> Self {
-                Self { foo }
-            }
-            #[cfg(not(feature = "foo"))]
-            fn new(bar: u32) -> Self {
-                Self { bar }
-            }
-        }
-        "#,
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""###);
-}
-#[test]
-fn no_such_field_with_feature_flag_diagnostics_on_block_expr() {
-    let diagnostics = TestDB::with_files(
-        r#"
-        //- /lib.rs crate:foo cfg:feature=foo
-        struct S {
-            #[cfg(feature = "foo")]
-            foo: u32,
-            #[cfg(not(feature = "foo"))]
-            bar: u32,
-        }
-        impl S {
-            fn new(bar: u32) -> Self {
-                #[cfg(feature = "foo")]
-                {
-                Self { foo: bar }
-                }
-                #[cfg(not(feature = "foo"))]
-                {
-                Self { bar }
-                }
-            }
-        }
-        "#,
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""###);
-}
-#[test]
-fn no_such_field_with_feature_flag_diagnostics_on_struct_fields() {
-    let diagnostics = TestDB::with_files(
-        r#"
-        //- /lib.rs crate:foo cfg:feature=foo
-        struct S {
-            #[cfg(feature = "foo")]
-            foo: u32,
-            #[cfg(not(feature = "foo"))]
-            bar: u32,
-        }
-        impl S {
-            fn new(val: u32) -> Self {
-                Self {
-                    #[cfg(feature = "foo")]
-                    foo: val,
-                    #[cfg(not(feature = "foo"))]
-                    bar: val,
-                }
-            }
-        }
-        "#,
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""###);
-}
-#[test]
-fn no_such_field_with_type_macro() {
-    let diagnostics = TestDB::with_files(
-        r"
-        macro_rules! Type {
-            () => { u32 };
-        }
-        struct Foo {
-            bar: Type![],
-        }
-        impl Foo {
-            fn new() -> Self {
-                Foo { bar: 0 }
-            }
-        }
-        ",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""###);
-}
-#[test]
-fn missing_record_pat_field_diagnostic() {
-    let diagnostics = TestDB::with_files(
-        r"
-        //- /lib.rs
-        struct S { foo: i32, bar: () }
-        fn baz(s: S) {
-            let S { foo: _ } = s;
-        }
-        ",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###"
-    "{ foo: _ }": Missing structure fields:
-    - bar
-    "###
-    );
-}
-#[test]
-fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() {
-    let diagnostics = TestDB::with_files(
-        r"
-        //- /lib.rs
-        struct S { foo: i32, bar: () }
-        fn baz(s: S) -> i32 {
-            match s {
-                S { foo, .. } => foo,
-            }
-        }
-        ",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @"");
-}
-#[test]
-fn missing_unsafe_diagnostic_with_raw_ptr() {
-    let diagnostics = TestDB::with_files(
-        r"
-//- /lib.rs
-fn missing_unsafe() {
-    let x = &5 as *const usize;
-    let y = *x;
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r#""*x": This operation is unsafe and requires an unsafe function or block"#);
-}
-#[test]
-fn missing_unsafe_diagnostic_with_unsafe_call() {
-    let diagnostics = TestDB::with_files(
-        r"
-//- /lib.rs
-unsafe fn unsafe_fn() {
-    let x = &5 as *const usize;
-    let y = *x;
-}
-fn missing_unsafe() {
-    unsafe_fn();
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r#""unsafe_fn()": This operation is unsafe and requires an unsafe function or block"#);
-}
-#[test]
-fn missing_unsafe_diagnostic_with_unsafe_method_call() {
-    let diagnostics = TestDB::with_files(
-        r"
-struct HasUnsafe;
-impl HasUnsafe {
-    unsafe fn unsafe_fn(&self) {
-        let x = &5 as *const usize;
-        let y = *x;
-    }
-}
-fn missing_unsafe() {
-    HasUnsafe.unsafe_fn();
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r#""HasUnsafe.unsafe_fn()": This operation is unsafe and requires an unsafe function or block"#);
-}
-#[test]
-fn no_missing_unsafe_diagnostic_with_raw_ptr_in_unsafe_block() {
-    let diagnostics = TestDB::with_files(
-        r"
-fn nothing_to_see_move_along() {
-    let x = &5 as *const usize;
-    unsafe {
-        let y = *x;
-    }
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @"");
-}
-#[test]
-fn missing_unsafe_diagnostic_with_raw_ptr_outside_unsafe_block() {
-    let diagnostics = TestDB::with_files(
-        r"
-fn nothing_to_see_move_along() {
-    let x = &5 as *const usize;
-    unsafe {
-        let y = *x;
-    }
-    let z = *x;
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r#""*x": This operation is unsafe and requires an unsafe function or block"#);
-}
-#[test]
-fn no_missing_unsafe_diagnostic_with_unsafe_call_in_unsafe_block() {
-    let diagnostics = TestDB::with_files(
-        r"
-unsafe fn unsafe_fn() {
-    let x = &5 as *const usize;
-    let y = *x;
-}
-fn nothing_to_see_move_along() {
-    unsafe {
-        unsafe_fn();
-    }
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @"");
-}
-#[test]
-fn no_missing_unsafe_diagnostic_with_unsafe_method_call_in_unsafe_block() {
-    let diagnostics = TestDB::with_files(
-        r"
-struct HasUnsafe;
-impl HasUnsafe {
-    unsafe fn unsafe_fn() {
-        let x = &5 as *const usize;
-        let y = *x;
-    }
-}
-fn nothing_to_see_move_along() {
-    unsafe {
-        HasUnsafe.unsafe_fn();
-    }
-}
-",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @"");
-}
-#[test]
-fn break_outside_of_loop() {
-    let diagnostics = TestDB::with_files(
-        r"
-        //- /lib.rs
-        fn foo() {
-            break;
-        }
-        ",
-    )
-    .diagnostics()
-    .0;
-    assert_snapshot!(diagnostics, @r###""break": break outside of loop
-    "###
-    );
-}
diff --git a/crates/ra_hir_ty/src/traits/builtin.rs b/crates/ra_hir_ty/src/traits/builtin.rs
index 86e22e459..60cc9a9f5 100644
--- a/crates/ra_hir_ty/src/traits/builtin.rs
+++ b/crates/ra_hir_ty/src/traits/builtin.rs
@@ -121,7 +121,7 @@ fn closure_fn_trait_impl_datum(
            .build(),
    );
    let sig_ty = Ty::apply(
-        TypeCtor::FnPtr { num_args },
+        TypeCtor::FnPtr { num_args, is_varargs: false },
        Substs::builder(num_args as usize + 1)
            .fill_with_bound_vars(DebruijnIndex::INNERMOST, 0)
            .build(),
diff --git a/crates/ra_hir_ty/src/traits/chalk/mapping.rs b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
index 06453ef82..3ebb55f77 100644
--- a/crates/ra_hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
@@ -30,7 +30,8 @@ impl ToChalk for Ty {
            Ty::Apply(apply_ty) => match apply_ty.ctor {
                TypeCtor::Ref(m) => ref_to_chalk(db, m, apply_ty.parameters),
                TypeCtor::Array => array_to_chalk(db, apply_ty.parameters),
-                TypeCtor::FnPtr { num_args: _ } => {
+                TypeCtor::FnPtr { num_args: _, is_varargs: _ } => {
+                    // FIXME: handle is_varargs
                    let substitution = apply_ty.parameters.to_chalk(db).shifted_in(&Interner);
                    chalk_ir::TyData::Function(chalk_ir::Fn { num_binders: 0, substitution })
                        .intern(&Interner)
@@ -124,7 +125,10 @@ impl ToChalk for Ty {
                    substitution.shifted_out(&Interner).expect("fn ptr should have no binders"),
                );
                Ty::Apply(ApplicationTy {
-                    ctor: TypeCtor::FnPtr { num_args: (parameters.len() - 1) as u16 },
+                    ctor: TypeCtor::FnPtr {
+                        num_args: (parameters.len() - 1) as u16,
+                        is_varargs: false,
+                    },
                    parameters,
                })
            }
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index df2fad520..6f8107491 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_ide"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index a6bdf1c9d..e1d6efb2a 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -93,7 +93,7 @@ fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Op
                    arg_list
                        .args()
                        .take_while(|arg| {
-                            arg.syntax().text_range().end() < token.text_range().start()
+                            arg.syntax().text_range().end() <= token.text_range().start()
                        })
                        .count(),
                );
@@ -213,169 +213,187 @@ impl CallInfo {
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
    use test_utils::mark;
    use crate::mock_analysis::analysis_and_position;
-    use super::*;
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
-    // These are only used when testing
+        let call_info = analysis.call_info(position).unwrap();
-    impl CallInfo {
+        let actual = match call_info {
-        fn doc(&self) -> Option<hir::Documentation> {
+            Some(call_info) => {
-            self.signature.doc.clone()
+                let docs = match &call_info.signature.doc {
-        }
+                    None => "".to_string(),
+                    Some(docs) => format!("{}\n------\n", docs.as_str()),
-        fn label(&self) -> String {
+                };
-            self.signature.to_string()
+                let params = call_info
-        }
+                    .parameters()
-    }
+                    .iter()
+                    .enumerate()
-    fn call_info_helper(text: &str) -> Option<CallInfo> {
+                    .map(|(i, param)| {
-        let (analysis, position) = analysis_and_position(text);
+                        if Some(i) == call_info.active_parameter {
-        analysis.call_info(position).unwrap()
+                            format!("<{}>", param)
-    }
+                        } else {
+                            param.clone()
-    fn call_info(text: &str) -> CallInfo {
+                        }
-        let info = call_info_helper(text);
+                    })
-        assert!(info.is_some());
+                    .collect::<Vec<_>>()
-        info.unwrap()
+                    .join(", ");
-    }
+                format!("{}{}\n({})\n", docs, call_info.signature, params)
+            }
-    fn no_call_info(text: &str) {
+            None => String::new(),
-        let info = call_info_helper(text);
+        };
-        assert!(info.is_none());
+        expect.assert_eq(&actual);
    }
    #[test]
-    fn test_fn_signature_two_args_firstx() {
+    fn test_fn_signature_two_args() {
-        let info = call_info(
+        check(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+            r#"
-fn bar() { foo(<|>3, ); }"#,
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>3, ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
        );
+        check(
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
+            r#"
-        assert_eq!(info.active_parameter, Some(0));
+fn foo(x: u32, y: u32) -> u32 {x + y}
-    }
+fn bar() { foo(3<|>, ); }
+"#,
-    #[test]
+            expect![[r#"
-    fn test_fn_signature_two_args_second() {
+                fn foo(x: u32, y: u32) -> u32
-        let info = call_info(
+                (<x: u32>, y: u32)
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+            "#]],
-fn bar() { foo(3, <|>); }"#,
+        );
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3,<|> ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (x: u32, <y: u32>)
+            "#]],
+        );
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3, <|>); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (x: u32, <y: u32>)
+            "#]],
        );
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(1));
    }
    #[test]
    fn test_fn_signature_two_args_empty() {
-        let info = call_info(
+        check(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+            r#"
-fn bar() { foo(<|>); }"#,
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
        );
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
    }
    #[test]
    fn test_fn_signature_two_args_first_generics() {
-        let info = call_info(
+        check(
-            r#"fn foo<T, U: Copy + Display>(x: T, y: U) -> u32 where T: Copy + Display, U: Debug {x + y}
-fn bar() { foo(<|>3, ); }"#,
-        );
-        assert_eq!(info.parameters(), ["x: T", "y: U"]);
-        assert_eq!(
-            info.label(),
            r#"
 fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
-where T: Copy + Display,
+    where T: Copy + Display, U: Debug
-      U: Debug
+{ x + y }
-    "#
-            .trim()
+fn bar() { foo(<|>3, ); }
+"#,
+            expect![[r#"
+                fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
+                where T: Copy + Display,
+                      U: Debug
+                (<x: T>, y: U)
+            "#]],
        );
-        assert_eq!(info.active_parameter, Some(0));
    }
    #[test]
    fn test_fn_signature_no_params() {
-        let info = call_info(
+        check(
-            r#"fn foo<T>() -> T where T: Copy + Display {}
-fn bar() { foo(<|>); }"#,
-        );
-        assert!(info.parameters().is_empty());
-        assert_eq!(
-            info.label(),
            r#"
-fn foo<T>() -> T
+fn foo<T>() -> T where T: Copy + Display {}
-where T: Copy + Display
+fn bar() { foo(<|>); }
-    "#
+"#,
-            .trim()
+            expect![[r#"
+                fn foo<T>() -> T
+                where T: Copy + Display
+                ()
+            "#]],
        );
-        assert!(info.active_parameter.is_none());
    }
    #[test]
    fn test_fn_signature_for_impl() {
-        let info = call_info(
+        check(
-            r#"struct F; impl F { pub fn new() { F{}} }
+            r#"
-fn bar() {let _ : F = F::new(<|>);}"#,
+struct F; impl F { pub fn new() { F{}} }
+fn bar() {let _ : F = F::new(<|>);}
+"#,
+            expect![[r#"
+                pub fn new()
+                ()
+            "#]],
        );
-        assert!(info.parameters().is_empty());
-        assert_eq!(info.active_parameter, None);
    }
    #[test]
    fn test_fn_signature_for_method_self() {
-        let info = call_info(
+        check(
-            r#"struct F;
+            r#"
-impl F {
+struct S;
-    pub fn new() -> F{
+impl S { pub fn do_it(&self) {} }
-        F{}
-    }
-    pub fn do_it(&self) {}
-}
 fn bar() {
-    let f : F = F::new();
+    let s: S = S;
-    f.do_it(<|>);
+    s.do_it(<|>);
-}"#,
+}
+"#,
+            expect![[r#"
+                pub fn do_it(&self)
+                (&self)
+            "#]],
        );
-        assert_eq!(info.parameters(), ["&self"]);
-        assert_eq!(info.active_parameter, None);
    }
    #[test]
    fn test_fn_signature_for_method_with_arg() {
-        let info = call_info(
+        check(
-            r#"struct F;
+            r#"
-impl F {
+struct S;
-    pub fn new() -> F{
+impl S { pub fn do_it(&self, x: i32) {} }
-        F{}
-    }
-    pub fn do_it(&self, x: i32) {}
-}
 fn bar() {
-    let f : F = F::new();
+    let s: S = S;
-    f.do_it(<|>);
+    s.do_it(<|>);
-}"#,
+}
+"#,
+            expect![[r#"
+                pub fn do_it(&self, x: i32)
+                (&self, <x: i32>)
+            "#]],
        );
-        assert_eq!(info.parameters(), ["&self", "x: i32"]);
-        assert_eq!(info.active_parameter, Some(1));
    }
    #[test]
    fn test_fn_signature_with_docs_simple() {
-        let info = call_info(
+        check(
            r#"
 /// test
 // non-doc-comment
@@ -387,17 +405,18 @@ fn bar() {
    let _ = foo(<|>);
 }
 "#,
+            expect![[r#"
+                test
+                ------
+                fn foo(j: u32) -> u32
+                (<j: u32>)
+            "#]],
        );
-        assert_eq!(info.parameters(), ["j: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "fn foo(j: u32) -> u32");
-        assert_eq!(info.doc().map(|it| it.into()), Some("test".to_string()));
    }
    #[test]
    fn test_fn_signature_with_docs() {
-        let info = call_info(
+        check(
            r#"
 /// Adds one to the number given.
 ///
@@ -415,31 +434,26 @@ pub fn add_one(x: i32) -> i32 {
 pub fn do() {
    add_one(<|>
 }"#,
-        );
+            expect![[r##"
+                Adds one to the number given.
-        assert_eq!(info.parameters(), ["x: i32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Adds one to the number given.
-# Examples
+                # Examples
-```
+                ```
-let five = 5;
+                let five = 5;
-assert_eq!(6, my_crate::add_one(5));
+                assert_eq!(6, my_crate::add_one(5));
-```"#
+                ```
-                    .to_string()
+                ------
-            )
+                pub fn add_one(x: i32) -> i32
+                (<x: i32>)
+            "##]],
        );
    }
    #[test]
    fn test_fn_signature_with_docs_impl() {
-        let info = call_info(
+        check(
            r#"
 struct addr;
 impl addr {
@@ -460,32 +474,28 @@ impl addr {
 pub fn do_it() {
    addr {};
    addr::add_one(<|>);
-}"#,
+}
-        );
+"#,
+            expect![[r##"
-        assert_eq!(info.parameters(), ["x: i32"]);
+                Adds one to the number given.
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Adds one to the number given.
-# Examples
+                # Examples
-```
+                ```
-let five = 5;
+                let five = 5;
-assert_eq!(6, my_crate::add_one(5));
+                assert_eq!(6, my_crate::add_one(5));
-```"#
+                ```
-                    .to_string()
+                ------
-            )
+                pub fn add_one(x: i32) -> i32
+                (<x: i32>)
+            "##]],
        );
    }
    #[test]
    fn test_fn_signature_with_docs_from_actix() {
-        let info = call_info(
+        check(
            r#"
 struct WriteHandler<E>;
@@ -509,101 +519,102 @@ impl<E> WriteHandler<E> {
 pub fn foo(mut r: WriteHandler<()>) {
    r.finished(<|>);
 }
 "#,
-        );
+            expect![[r#"
+                Method is called when writer finishes.
-        assert_eq!(info.label(), "fn finished(&mut self, ctx: &mut Self::Context)".to_string());
-        assert_eq!(info.parameters(), ["&mut self", "ctx: &mut Self::Context"]);
+                By default this method stops actor's `Context`.
-        assert_eq!(info.active_parameter, Some(1));
+                ------
-        assert_eq!(
+                fn finished(&mut self, ctx: &mut Self::Context)
-            info.doc().map(|it| it.into()),
+                (&mut self, <ctx: &mut Self::Context>)
-            Some(
+            "#]],
-                r#"Method is called when writer finishes.
-By default this method stops actor's `Context`."#
-                    .to_string()
-            )
        );
    }
    #[test]
    fn call_info_bad_offset() {
        mark::check!(call_info_bad_offset);
-        let (analysis, position) = analysis_and_position(
+        check(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+            r#"
-               fn bar() { foo <|> (3, ); }"#,
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo <|> (3, ); }
+"#,
+            expect![[""]],
        );
-        let call_info = analysis.call_info(position).unwrap();
-        assert!(call_info.is_none());
    }
    #[test]
-    fn test_nested_method_in_lamba() {
+    fn test_nested_method_in_lambda() {
-        let info = call_info(
+        check(
-            r#"struct Foo;
+            r#"
+struct Foo;
-impl Foo {
+impl Foo { fn bar(&self, _: u32) { } }
-    fn bar(&self, _: u32) { }
-}
 fn bar(_: u32) { }
 fn main() {
    let foo = Foo;
    std::thread::spawn(move || foo.bar(<|>));
-}"#,
+}
+"#,
+            expect![[r#"
+                fn bar(&self, _: u32)
+                (&self, <_: u32>)
+            "#]],
        );
-        assert_eq!(info.parameters(), ["&self", "_: u32"]);
-        assert_eq!(info.active_parameter, Some(1));
-        assert_eq!(info.label(), "fn bar(&self, _: u32)");
    }
    #[test]
    fn works_for_tuple_structs() {
-        let info = call_info(
+        check(
            r#"
 /// A cool tuple struct
 struct TS(u32, i32);
 fn main() {
    let s = TS(0, <|>);
-}"#,
+}
+"#,
+            expect![[r#"
+                A cool tuple struct
+                ------
+                struct TS(u32, i32) -> TS
+                (u32, <i32>)
+            "#]],
        );
-        assert_eq!(info.label(), "struct TS(u32, i32) -> TS");
-        assert_eq!(info.doc().map(|it| it.into()), Some("A cool tuple struct".to_string()));
-        assert_eq!(info.active_parameter, Some(1));
    }
    #[test]
    fn generic_struct() {
-        let info = call_info(
+        check(
            r#"
 struct TS<T>(T);
 fn main() {
    let s = TS(<|>);
-}"#,
+}
+"#,
+            expect![[r#"
+                struct TS<T>(T) -> TS
+                (<T>)
+            "#]],
        );
-        assert_eq!(info.label(), "struct TS<T>(T) -> TS");
-        assert_eq!(info.active_parameter, Some(0));
    }
    #[test]
    fn cant_call_named_structs() {
-        no_call_info(
+        check(
            r#"
 struct TS { x: u32, y: i32 }
 fn main() {
    let s = TS(<|>);
-}"#,
+}
+"#,
+            expect![[""]],
        );
    }
    #[test]
    fn works_for_enum_variants() {
-        let info = call_info(
+        check(
            r#"
 enum E {
    /// A Variant
@@ -617,17 +628,19 @@ enum E {
 fn main() {
    let a = E::A(<|>);
 }
-            "#,
+"#,
+            expect![[r#"
+                A Variant
+                ------
+                E::A(0: i32)
+                (<0: i32>)
+            "#]],
        );
-        assert_eq!(info.label(), "E::A(0: i32)");
-        assert_eq!(info.doc().map(|it| it.into()), Some("A Variant".to_string()));
-        assert_eq!(info.active_parameter, Some(0));
    }
    #[test]
    fn cant_call_enum_records() {
-        no_call_info(
+        check(
            r#"
 enum E {
    /// A Variant
@@ -641,13 +654,14 @@ enum E {
 fn main() {
    let a = E::C(<|>);
 }
-            "#,
+"#,
+            expect![[""]],
        );
    }
    #[test]
    fn fn_signature_for_macro() {
-        let info = call_info(
+        check(
            r#"
 /// empty macro
 macro_rules! foo {
@@ -657,31 +671,30 @@ macro_rules! foo {
 fn f() {
    foo!(<|>);
 }
-        "#,
+"#,
+            expect![[r#"
+                empty macro
+                ------
+                foo!()
+                ()
+            "#]],
        );
-        assert_eq!(info.label(), "foo!()");
-        assert_eq!(info.doc().map(|it| it.into()), Some("empty macro".to_string()));
    }
    #[test]
    fn fn_signature_for_call_in_macro() {
-        let info = call_info(
+        check(
            r#"
-            macro_rules! id {
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
-                ($($tt:tt)*) => { $($tt)* }
+fn foo() { }
-            }
+id! {
-            fn foo() {
+    fn bar() { foo(<|>); }
+}
-            }
+"#,
-            id! {
+            expect![[r#"
-                fn bar() {
+                fn foo()
-                    foo(<|>);
+                ()
-                }
+            "#]],
-            }
-            "#,
        );
-        assert_eq!(info.label(), "fn foo()");
    }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 3d93f7067..9e82d6854 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -63,6 +63,8 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) dot_receiver_is_ambiguous_float_literal: bool,
    /// If this is a call (method or function) in particular, i.e. the () are already there.
    pub(super) is_call: bool,
+    /// Like `is_call`, but for tuple patterns.
+    pub(super) is_pattern_call: bool,
    /// If this is a macro call, i.e. the () are already there.
    pub(super) is_macro_call: bool,
    pub(super) is_path_type: bool,
@@ -136,6 +138,7 @@ impl<'a> CompletionContext<'a> {
            is_new_item: false,
            dot_receiver: None,
            is_call: false,
+            is_pattern_call: false,
            is_macro_call: false,
            is_path_type: false,
            has_type_args: false,
@@ -370,6 +373,8 @@ impl<'a> CompletionContext<'a> {
                .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
                .is_some();
            self.is_macro_call = path.syntax().parent().and_then(ast::MacroCall::cast).is_some();
+            self.is_pattern_call =
+                path.syntax().parent().and_then(ast::TupleStructPat::cast).is_some();
            self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
            self.has_type_args = segment.type_arg_list().is_some();
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 48afee5fb..64349dcb8 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -315,6 +315,7 @@ impl Completions {
        }
        if variant_kind == StructKind::Tuple {
+            mark::hit!(inserts_parens_for_tuple_enums);
            let params = Params::Anonymous(variant.fields(ctx.db).len());
            res = res.add_call_parens(ctx, qualified_name, params)
        }
@@ -383,10 +384,17 @@ impl Builder {
        if !ctx.config.add_call_parenthesis {
            return self;
        }
-        if ctx.use_item_syntax.is_some() || ctx.is_call {
+        if ctx.use_item_syntax.is_some() {
            mark::hit!(no_parens_in_use_item);
            return self;
        }
+        if ctx.is_pattern_call {
+            mark::hit!(dont_duplicate_pattern_parens);
+            return self;
+        }
+        if ctx.is_call {
+            return self;
+        }
        // Don't add parentheses if the expected type is some function reference.
        if let Some(ty) = &ctx.expected_type {
@@ -865,6 +873,7 @@ fn main() { foo(${1:foo}, ${2:bar}, ${3:ho_ge_})$0 }
    #[test]
    fn inserts_parens_for_tuple_enums() {
+        mark::check!(inserts_parens_for_tuple_enums);
        check_edit(
            "Some",
            r#"
@@ -906,6 +915,30 @@ fn main(value: Option<i32>) {
    }
    #[test]
+    fn dont_duplicate_pattern_parens() {
+        mark::check!(dont_duplicate_pattern_parens);
+        check_edit(
+            "Var",
+            r#"
+enum E { Var(i32) }
+fn main() {
+    match E::Var(92) {
+        E::<|>(92) => (),
+    }
+}
+"#,
+            r#"
+enum E { Var(i32) }
+fn main() {
+    match E::Var(92) {
+        E::Var(92) => (),
+    }
+}
+"#,
+        );
+    }
+    #[test]
    fn no_call_parens_if_fn_ptr_needed() {
        mark::check!(no_call_parens_if_fn_ptr_needed);
        check_edit(
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 3afe5381a..fe75f4b2c 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -35,8 +35,8 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
    let parse = db.parse(file_id);
    let mut res = Vec::new();
-    // [#34344] Only take first 500 errors to prevent slowing down editor/ide, the number 500 is chosen arbitrarily.
+    // [#34344] Only take first 128 errors to prevent slowing down editor/ide, the number 128 is chosen arbitrarily.
-    res.extend(parse.errors().iter().take(500).map(|err| Diagnostic {
+    res.extend(parse.errors().iter().take(128).map(|err| Diagnostic {
        range: err.range(),
        message: format!("Syntax Error: {}", err),
        severity: Severity::Error,
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index f575d738f..c30b20611 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -866,4 +866,22 @@ type Alias<T> = T<|>;
 "#,
        )
    }
+    #[test]
+    fn goto_def_for_macro_container() {
+        check(
+            r#"
+//- /lib.rs
+foo::module<|>::mac!();
+//- /foo/lib.rs
+pub mod module {
+      //^^^^^^
+    #[macro_export]
+    macro_rules! _mac { () => { () } }
+    pub use crate::_mac as mac;
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 5bb6f9642..6ac44c2c0 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -553,6 +553,7 @@ fn highlight_element(
        T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
            Highlight::new(HighlightTag::Macro)
        }
+        p if p.is_punct() => HighlightTag::Punctuation.into(),
        k if k.is_keyword() => {
            let h = Highlight::new(HighlightTag::Keyword);
@@ -566,10 +567,31 @@ fn highlight_element(
                | T![return]
                | T![while]
                | T![in] => h | HighlightModifier::ControlFlow,
-                T![for] if !is_child_of_impl(element) => h | HighlightModifier::ControlFlow,
+                T![for] if !is_child_of_impl(&element) => h | HighlightModifier::ControlFlow,
                T![unsafe] => h | HighlightModifier::Unsafe,
                T![true] | T![false] => HighlightTag::BoolLiteral.into(),
-                T![self] => HighlightTag::SelfKeyword.into(),
+                T![self] => {
+                    let self_param_is_mut = element
+                        .parent()
+                        .and_then(ast::SelfParam::cast)
+                        .and_then(|p| p.mut_token())
+                        .is_some();
+                    // closure to enforce lazyness
+                    let self_path = || {
+                        sema.resolve_path(&element.parent()?.parent().and_then(ast::Path::cast)?)
+                    };
+                    if self_param_is_mut
+                        || matches!(self_path(),
+                            Some(hir::PathResolution::Local(local))
+                                if local.is_self(db)
+                                    && (local.is_mut(db) || local.ty(db).is_mutable_reference())
+                        )
+                    {
+                        HighlightTag::SelfKeyword | HighlightModifier::Mutable
+                    } else {
+                        HighlightTag::SelfKeyword.into()
+                    }
+                }
                _ => h,
            }
        }
@@ -592,7 +614,7 @@ fn highlight_element(
    }
 }
-fn is_child_of_impl(element: SyntaxElement) -> bool {
+fn is_child_of_impl(element: &SyntaxElement) -> bool {
    match element.parent() {
        Some(e) => e.kind() == IMPL_DEF,
        _ => false,
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index 719c6ed3c..49ec94bdc 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -32,6 +32,7 @@ pub enum HighlightTag {
    Macro,
    Module,
    NumericLiteral,
+    Punctuation,
    SelfKeyword,
    SelfType,
    Static,
@@ -83,6 +84,7 @@ impl HighlightTag {
            HighlightTag::Generic => "generic",
            HighlightTag::Keyword => "keyword",
            HighlightTag::Lifetime => "lifetime",
+            HighlightTag::Punctuation => "punctuation",
            HighlightTag::Macro => "macro",
            HighlightTag::Module => "module",
            HighlightTag::NumericLiteral => "numeric_literal",
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index aa7c887d6..87a6e2523 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -25,6 +25,16 @@ impl Bar for Foo {
    }
 }
+impl Foo {
+    fn baz(mut self) -> i32 {
+        self.x
+    }
+    fn qux(&mut self) {
+        self.x = 0;
+    }
+}
 static mut STATIC_MUT: i32 = 0;
 fn foo<'a, T>() -> T {
diff --git a/crates/ra_ide/test_data/highlight_doctest.html b/crates/ra_ide/test_data/highlight_doctest.html
index a77fabb68..1cc17d6d0 100644
--- a/crates/ra_ide/test_data/highlight_doctest.html
+++ b/crates/ra_ide/test_data/highlight_doctest.html
@@ -36,67 +36,67 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="comment documentation">/// ```</span>
-<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> _ = </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="generic injected">;</span>
+<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="punctuation injected">_</span><span class="generic injected"> </span><span class="punctuation injected">=</span><span class="generic injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="punctuation injected">;</span><span class="punctuation injected">
-<span class="comment documentation">/// ```</span>
+</span><span class="comment documentation">/// ```</span>
-<span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
+<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
-    <span class="field declaration">bar</span>: <span class="builtin_type">bool</span>,
+    <span class="field declaration">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span><span class="punctuation">,</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">impl</span> <span class="struct">Foo</span> {
+<span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span>: <span class="builtin_type">bool</span> = <span class="bool_literal">true</span>;
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span> <span class="punctuation">=</span> <span class="bool_literal">true</span><span class="punctuation">;</span>
    <span class="comment documentation">/// Constructs a new `Foo`.</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// # Examples</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// #</span><span class="generic injected"> </span><span class="attribute injected">#![</span><span class="function attribute injected">allow</span><span class="attribute injected">(unused_mut)]</span>
+    <span class="comment documentation">/// #</span><span class="generic injected"> </span><span class="punctuation injected">#</span><span class="punctuation injected">!</span><span class="punctuation injected">[</span><span class="function attribute injected">allow</span><span class="punctuation injected">(</span><span class="attribute injected">unused_mut</span><span class="punctuation injected">)</span><span class="punctuation injected">]</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="keyword injected">mut</span><span class="generic injected"> </span><span class="variable declaration injected mutable">foo</span><span class="generic injected">: </span><span class="struct injected">Foo</span><span class="generic injected"> = </span><span class="struct injected">Foo</span><span class="generic injected">::</span><span class="function injected">new</span><span class="generic injected">();</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="keyword injected">mut</span><span class="generic injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="generic injected"> </span><span class="punctuation injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="punctuation injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
-    <span class="comment documentation">/// ```</span>
+</span>    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="struct">Foo</span> {
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-        <span class="struct">Foo</span> { <span class="field">bar</span>: <span class="bool_literal">true</span> }
+        <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">bar</span><span class="punctuation">:</span> <span class="bool_literal">true</span> <span class="punctuation">}</span>
-    }
+    <span class="punctuation">}</span>
    <span class="comment documentation">/// `bar` method on `Foo`.</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// # Examples</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="generic injected"> </span><span class="module injected">x</span><span class="generic injected">::</span><span class="module injected">y</span><span class="generic injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="generic injected"> </span><span class="module injected">x</span><span class="punctuation injected">::</span><span class="module injected">y</span><span class="punctuation injected">;</span>
    <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">foo</span><span class="generic injected"> = </span><span class="struct injected">Foo</span><span class="generic injected">::</span><span class="function injected">new</span><span class="generic injected">();</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">foo</span><span class="generic injected"> </span><span class="punctuation injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="punctuation injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// </span><span class="comment injected">// calls bar on foo</span>
-    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="generic injected">(foo.bar());</span>
+    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="punctuation injected">(</span><span class="generic injected">foo</span><span class="punctuation injected">.</span><span class="generic injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
    <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">bar</span><span class="generic injected"> = </span><span class="variable injected">foo</span><span class="generic injected">.</span><span class="field injected">bar</span><span class="generic injected"> || </span><span class="struct injected">Foo</span><span class="generic injected">::</span><span class="constant injected">bar</span><span class="generic injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">bar</span><span class="generic injected"> </span><span class="punctuation injected">=</span><span class="generic injected"> </span><span class="variable injected">foo</span><span class="punctuation injected">.</span><span class="field injected">bar</span><span class="generic injected"> </span><span class="punctuation injected">||</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="punctuation injected">::</span><span class="constant injected">bar</span><span class="punctuation injected">;</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// </span><span class="comment injected">/* multi-line
    </span><span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
    <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="generic injected"> = </span><span class="string_literal injected">"Foo
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="generic injected"> </span><span class="punctuation injected">=</span><span class="generic injected"> </span><span class="string_literal injected">"Foo
    </span><span class="comment documentation">/// </span><span class="string_literal injected">  bar
-    </span><span class="comment documentation">/// </span><span class="string_literal injected">         "</span><span class="generic injected">;</span>
+    </span><span class="comment documentation">/// </span><span class="string_literal injected">         "</span><span class="punctuation injected">;</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// ```</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// ```rust,no_run</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">foobar</span><span class="generic injected"> = </span><span class="struct injected">Foo</span><span class="generic injected">::</span><span class="function injected">new</span><span class="generic injected">().</span><span class="function injected">bar</span><span class="generic injected">();</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="variable declaration injected">foobar</span><span class="generic injected"> </span><span class="punctuation injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="punctuation injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">.</span><span class="function injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
-    <span class="comment documentation">/// ```</span>
+</span>    <span class="comment documentation">/// ```</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// ```sh</span>
    <span class="comment documentation">/// echo 1</span>
    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">foo</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">bool</span> {
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">foo</span><span class="punctuation">(</span><span class="punctuation">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="builtin_type">bool</span> <span class="punctuation">{</span>
        <span class="bool_literal">true</span>
-    }
+    <span class="punctuation">}</span>
-}
+<span class="punctuation">}</span>
 <span class="comment documentation">/// ```</span>
-<span class="comment documentation">/// </span><span class="macro injected">noop!</span><span class="generic injected">(</span><span class="numeric_literal injected">1</span><span class="generic injected">);</span>
+<span class="comment documentation">/// </span><span class="macro injected">noop!</span><span class="punctuation injected">(</span><span class="numeric_literal injected">1</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
-<span class="comment documentation">/// ```</span>
+</span><span class="comment documentation">/// ```</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> {
+<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
-    ($expr:expr) =&gt; {
+    <span class="punctuation">(</span><span class="punctuation">$</span>expr<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="punctuation">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-        $expr
+        <span class="punctuation">$</span>expr
-    }
+    <span class="punctuation">}</span>
-}</code></pre>
-\ No newline at end of file
+<span class="punctuation">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ra_ide/test_data/highlight_injection.html b/crates/ra_ide/test_data/highlight_injection.html
index e15234936..461cfc437 100644
--- a/crates/ra_ide/test_data/highlight_injection.html
+++ b/crates/ra_ide/test_data/highlight_injection.html
@@ -35,14 +35,14 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span>(<span class="value_param declaration">ra_fixture</span>: &<span class="builtin_type">str</span>) {}
+<pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span><span class="punctuation">(</span><span class="value_param declaration">ra_fixture</span><span class="punctuation">:</span> <span class="punctuation">&</span><span class="builtin_type">str</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="function">fixture</span>(<span class="string_literal">r#"</span>
+    <span class="function">fixture</span><span class="punctuation">(</span><span class="string_literal">r#"</span>
-        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> {
+        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="punctuation">{</span>
-            <span class="keyword">fn</span> <span class="function declaration">foo</span>() {
+            <span class="keyword">fn</span> <span class="function declaration">foo</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-                <span class="macro">println!</span>(<span class="string_literal">"2 + 2 = {}"</span>, <span class="numeric_literal">4</span>);
+                <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"2 + 2 = {}"</span><span class="punctuation">,</span> <span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">;</span>
-            }
+            <span class="punctuation">}</span>
-        }<span class="string_literal">"#</span>
+        <span class="punctuation">}</span><span class="string_literal">"#</span>
-    );
+    <span class="punctuation">)</span><span class="punctuation">;</span>
-}</code></pre>
-\ No newline at end of file
+<span class="punctuation">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ra_ide/test_data/highlight_strings.html b/crates/ra_ide/test_data/highlight_strings.html
index 423813366..9f98e73e7 100644
--- a/crates/ra_ide/test_data/highlight_strings.html
+++ b/crates/ra_ide/test_data/highlight_strings.html
@@ -35,62 +35,62 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> {
+<pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> <span class="punctuation">{</span>
-    ($($arg:tt)*) =&gt; ({
+    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">:</span>tt<span class="punctuation">)</span>*<span class="punctuation">)</span> <span class="punctuation">=</span><span class="punctuation">&gt;</span> <span class="punctuation">(</span><span class="punctuation">{</span>
-        $<span class="keyword">crate</span>::io::_print($<span class="keyword">crate</span>::format_args_nl!($($arg)*));
+        <span class="punctuation">$</span><span class="keyword">crate</span><span class="punctuation">:</span><span class="punctuation">:</span>io<span class="punctuation">:</span><span class="punctuation">:</span>_print<span class="punctuation">(</span><span class="punctuation">$</span><span class="keyword">crate</span><span class="punctuation">:</span><span class="punctuation">:</span>format_args_nl<span class="punctuation">!</span><span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">)</span>*<span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    })
+    <span class="punctuation">}</span><span class="punctuation">)</span>
-}
+<span class="punctuation">}</span>
 #[rustc_builtin_macro]
-<span class="macro">macro_rules!</span> <span class="macro declaration">format_args_nl</span> {
+<span class="macro">macro_rules!</span> <span class="macro declaration">format_args_nl</span> <span class="punctuation">{</span>
-    ($fmt:expr) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
+    <span class="punctuation">(</span><span class="punctuation">$</span>fmt<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="punctuation">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">{</span> <span class="comment">/* compiler built-in */</span> <span class="punctuation">}</span><span class="punctuation">}</span><span class="punctuation">;</span>
-    ($fmt:expr, $($args:tt)*) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
+    <span class="punctuation">(</span><span class="punctuation">$</span>fmt<span class="punctuation">:</span>expr<span class="punctuation">,</span> <span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>args<span class="punctuation">:</span>tt<span class="punctuation">)</span>*<span class="punctuation">)</span> <span class="punctuation">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">{</span> <span class="comment">/* compiler built-in */</span> <span class="punctuation">}</span><span class="punctuation">}</span><span class="punctuation">;</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
    <span class="comment">// from https://doc.rust-lang.org/std/fmt/index.html</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello"</span>);                 <span class="comment">// =&gt; "Hello"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello"</span><span class="punctuation">)</span><span class="punctuation">;</span>                 <span class="comment">// =&gt; "Hello"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);   <span class="comment">// =&gt; "Hello, world!"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"world"</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "Hello, world!"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"The number is </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>);   <span class="comment">// =&gt; "The number is 1"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"The number is </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "The number is 1"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal">"</span>, (<span class="numeric_literal">3</span>, <span class="numeric_literal">4</span>));          <span class="comment">// =&gt; "(3, 4)"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="punctuation">(</span><span class="numeric_literal">3</span><span class="punctuation">,</span> <span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>          <span class="comment">// =&gt; "(3, 4)"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">value</span><span class="format_specifier">}</span><span class="string_literal">"</span>, value=<span class="numeric_literal">4</span>);      <span class="comment">// =&gt; "4"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">value</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> value<span class="punctuation">=</span><span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">;</span>      <span class="comment">// =&gt; "4"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>, <span class="numeric_literal">2</span>);           <span class="comment">// =&gt; "1 2"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">,</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>           <span class="comment">// =&gt; "1 2"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">4</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">42</span>);             <span class="comment">// =&gt; "0042" with leading zerosV</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">4</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">42</span><span class="punctuation">)</span><span class="punctuation">;</span>             <span class="comment">// =&gt; "0042" with leading zerosV</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>, <span class="numeric_literal">2</span>);   <span class="comment">// =&gt; "2 1 1 2"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">,</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "2 1 1 2"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">argument</span><span class="format_specifier">}</span><span class="string_literal">"</span>, argument = <span class="string_literal">"test"</span>);   <span class="comment">// =&gt; "test"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">argument</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> argument <span class="punctuation">=</span> <span class="string_literal">"test"</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "test"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">1</span>, name = <span class="numeric_literal">2</span>);          <span class="comment">// =&gt; "2 1"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">,</span> name <span class="punctuation">=</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>          <span class="comment">// =&gt; "2 1"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">a</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">c</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">b</span><span class="format_specifier">}</span><span class="string_literal">"</span>, a=<span class="string_literal">"a"</span>, b=<span class="char_literal">'b'</span>, c=<span class="numeric_literal">3</span>);  <span class="comment">// =&gt; "a 3 b"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">a</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">c</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">b</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> a<span class="punctuation">=</span><span class="string_literal">"a"</span><span class="punctuation">,</span> b<span class="punctuation">=</span><span class="char_literal">'b'</span><span class="punctuation">,</span> c<span class="punctuation">=</span><span class="numeric_literal">3</span><span class="punctuation">)</span><span class="punctuation">;</span>  <span class="comment">// =&gt; "a 3 b"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"{{</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">}}"</span>, <span class="numeric_literal">2</span>);                       <span class="comment">// =&gt; "{2}"</span>
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"{{</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">}}"</span><span class="punctuation">,</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>                       <span class="comment">// =&gt; "{2}"</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>, <span class="string_literal">"x"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">width</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>, width = <span class="numeric_literal">5</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">width</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> width <span class="punctuation">=</span> <span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">-</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">-</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">^</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">^</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"x"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">27</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">27</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">5</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, -<span class="numeric_literal">5</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="punctuation">-</span><span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="numeric_literal">27</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">27</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">0.01</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="numeric_literal">5</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">0.01</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>, <span class="numeric_literal">0.01</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span>,    <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>, <span class="numeric_literal">0.01</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span>    <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span>,   <span class="string_literal">"x"</span>, <span class="numeric_literal">5</span>, <span class="numeric_literal">0.01</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span>   <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="variable">number</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="variable">prec</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span>, <span class="string_literal">"x"</span>, prec = <span class="numeric_literal">5</span>, number = <span class="numeric_literal">0.01</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="variable">number</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="variable">prec</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> prec <span class="punctuation">=</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> number <span class="punctuation">=</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 fractional digits"</span>, <span class="string_literal">"Hello"</span>, <span class="numeric_literal">3</span>, name=<span class="numeric_literal">1234.56</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 fractional digits"</span><span class="punctuation">,</span> <span class="string_literal">"Hello"</span><span class="punctuation">,</span> <span class="numeric_literal">3</span><span class="punctuation">,</span> name<span class="punctuation">=</span><span class="numeric_literal">1234.56</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 characters"</span>, <span class="string_literal">"Hello"</span>, <span class="numeric_literal">3</span>, name=<span class="string_literal">"1234.56"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 characters"</span><span class="punctuation">,</span> <span class="string_literal">"Hello"</span><span class="punctuation">,</span> <span class="numeric_literal">3</span><span class="punctuation">,</span> name<span class="punctuation">=</span><span class="string_literal">"1234.56"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">8</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 right-aligned characters"</span>, <span class="string_literal">"Hello"</span>, <span class="numeric_literal">3</span>, name=<span class="string_literal">"1234.56"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">8</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 right-aligned characters"</span><span class="punctuation">,</span> <span class="string_literal">"Hello"</span><span class="punctuation">,</span> <span class="numeric_literal">3</span><span class="punctuation">,</span> name<span class="punctuation">=</span><span class="string_literal">"1234.56"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello {{}}"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello {{}}"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"{{ Hello"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"{{ Hello"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"world"</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="comment">// escape sequences</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> A <span class="punctuation">=</span> <span class="numeric_literal">92</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span>, ничоси = <span class="numeric_literal">92</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> ничоси <span class="punctuation">=</span> <span class="numeric_literal">92</span><span class="punctuation">)</span><span class="punctuation">;</span>
-}</code></pre>
-\ No newline at end of file
+<span class="punctuation">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ra_ide/test_data/highlight_unsafe.html b/crates/ra_ide/test_data/highlight_unsafe.html
index 7585fbb42..88ac91f9a 100644
--- a/crates/ra_ide/test_data/highlight_unsafe.html
+++ b/crates/ra_ide/test_data/highlight_unsafe.html
@@ -35,20 +35,20 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration unsafe">unsafe_fn</span>() {}
+<pre><code><span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration unsafe">unsafe_fn</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span>;
+<span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span><span class="punctuation">;</span>
-<span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> {
+<span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> <span class="punctuation">{</span>
-    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration unsafe">unsafe_method</span>(&<span class="self_keyword">self</span>) {}
+    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration unsafe">unsafe_method</span><span class="punctuation">(</span><span class="punctuation">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="keyword">let</span> <span class="variable declaration">x</span> = &<span class="numeric_literal">5</span> <span class="keyword">as</span> *<span class="keyword">const</span> <span class="builtin_type">usize</span>;
+    <span class="keyword">let</span> <span class="variable declaration">x</span> <span class="punctuation">=</span> <span class="punctuation">&</span><span class="numeric_literal">5</span> <span class="keyword">as</span> *<span class="keyword">const</span> <span class="builtin_type">usize</span><span class="punctuation">;</span>
-    <span class="keyword unsafe">unsafe</span> {
+    <span class="keyword unsafe">unsafe</span> <span class="punctuation">{</span>
-        <span class="function unsafe">unsafe_fn</span>();
+        <span class="function unsafe">unsafe_fn</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-        <span class="struct">HasUnsafeFn</span>.<span class="function unsafe">unsafe_method</span>();
+        <span class="struct">HasUnsafeFn</span><span class="punctuation">.</span><span class="function unsafe">unsafe_method</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="variable declaration">y</span> = <span class="operator unsafe">*</span>(<span class="variable">x</span>);
+        <span class="keyword">let</span> <span class="variable declaration">y</span> <span class="punctuation">=</span> <span class="operator unsafe">*</span><span class="punctuation">(</span><span class="variable">x</span><span class="punctuation">)</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="variable declaration">z</span> = -<span class="variable">x</span>;
+        <span class="keyword">let</span> <span class="variable declaration">z</span> <span class="punctuation">=</span> <span class="punctuation">-</span><span class="variable">x</span><span class="punctuation">;</span>
-    }
+    <span class="punctuation">}</span>
-}</code></pre>
-\ No newline at end of file
+<span class="punctuation">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ra_ide/test_data/highlighting.html b/crates/ra_ide/test_data/highlighting.html
index 134743c72..767e82f9d 100644
--- a/crates/ra_ide/test_data/highlighting.html
+++ b/crates/ra_ide/test_data/highlighting.html
@@ -35,84 +35,94 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="attribute">#[</span><span class="function attribute">derive</span><span class="attribute">(Clone, Debug)]</span>
+<pre><code><span class="punctuation">#</span><span class="punctuation">[</span><span class="function attribute">derive</span><span class="punctuation">(</span><span class="attribute">Clone</span><span class="punctuation">,</span><span class="attribute"> Debug</span><span class="punctuation">)</span><span class="punctuation">]</span>
-<span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
+<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="field declaration">x</span>: <span class="builtin_type">i32</span>,
+    <span class="keyword">pub</span> <span class="field declaration">x</span><span class="punctuation">:</span> <span class="builtin_type">i32</span><span class="punctuation">,</span>
-    <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>,
+    <span class="keyword">pub</span> <span class="field declaration">y</span><span class="punctuation">:</span> <span class="builtin_type">i32</span><span class="punctuation">,</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">trait</span> <span class="trait declaration">Bar</span> {
+<span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">i32</span>;
+    <span class="keyword">fn</span> <span class="function declaration">bar</span><span class="punctuation">(</span><span class="punctuation">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="builtin_type">i32</span><span class="punctuation">;</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> {
+<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">i32</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span><span class="punctuation">(</span><span class="punctuation">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
-        <span class="self_keyword">self</span>.<span class="field">x</span>
+        <span class="self_keyword">self</span><span class="punctuation">.</span><span class="field">x</span>
-    }
+    <span class="punctuation">}</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable">STATIC_MUT</span>: <span class="builtin_type">i32</span> = <span class="numeric_literal">0</span>;
+<span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
-<span class="keyword">fn</span> <span class="function declaration">foo</span>&lt;<span class="lifetime declaration">'a</span>, <span class="type_param declaration">T</span>&gt;() -&gt; <span class="type_param">T</span> {
+        <span class="self_keyword">self</span><span class="punctuation">.</span><span class="field">x</span>
-    <span class="function">foo</span>::&lt;<span class="lifetime">'a</span>, <span class="builtin_type">i32</span>&gt;()
+    <span class="punctuation">}</span>
-}
+    <span class="keyword">fn</span> <span class="function declaration">qux</span><span class="punctuation">(</span><span class="punctuation">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> {
+        <span class="self_keyword mutable">self</span><span class="punctuation">.</span><span class="field">x</span> <span class="punctuation">=</span> <span class="numeric_literal">0</span><span class="punctuation">;</span>
-    ($($tt:tt)*) =&gt; {$($tt)*}
+    <span class="punctuation">}</span>
-}
+<span class="punctuation">}</span>
-<span class="macro">def_fn!</span> {
+<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable">STATIC_MUT</span><span class="punctuation">:</span> <span class="builtin_type">i32</span> <span class="punctuation">=</span> <span class="numeric_literal">0</span><span class="punctuation">;</span>
-    <span class="keyword">fn</span> <span class="function declaration">bar</span>() -&gt; <span class="builtin_type">u32</span> {
+<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="punctuation">&lt;</span><span class="lifetime declaration">'a</span><span class="punctuation">,</span> <span class="type_param declaration">T</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="type_param">T</span> <span class="punctuation">{</span>
+    <span class="function">foo</span><span class="punctuation">::</span><span class="punctuation">&lt;</span><span class="lifetime">'a</span><span class="punctuation">,</span> <span class="builtin_type">i32</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="punctuation">)</span>
+<span class="punctuation">}</span>
+<span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> <span class="punctuation">{</span>
+    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<span class="punctuation">:</span>tt<span class="punctuation">)</span>*<span class="punctuation">)</span> <span class="punctuation">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<span class="punctuation">)</span>*<span class="punctuation">}</span>
+<span class="punctuation">}</span>
+<span class="macro">def_fn!</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration">bar</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">-</span><span class="punctuation">&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
        <span class="numeric_literal">100</span>
-    }
+    <span class="punctuation">}</span>
-}
+<span class="punctuation">}</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> {
+<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
-    ($expr:expr) =&gt; {
+    <span class="punctuation">(</span><span class="punctuation">$</span>expr<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="punctuation">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-        $expr
+        <span class="punctuation">$</span>expr
-    }
+    <span class="punctuation">}</span>
-}
+<span class="punctuation">}</span>
 <span class="comment">// comment</span>
-<span class="keyword">fn</span> <span class="function declaration">main</span>() {
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="macro">println!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>);
+    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello, {}!"</span><span class="punctuation">,</span> <span class="numeric_literal">92</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> = <span class="unresolved_reference">Vec</span>::<span class="unresolved_reference">new</span>();
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> <span class="punctuation">=</span> <span class="unresolved_reference">Vec</span><span class="punctuation">::</span><span class="unresolved_reference">new</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword control">if</span> <span class="bool_literal">true</span> {
+    <span class="keyword control">if</span> <span class="bool_literal">true</span> <span class="punctuation">{</span>
-        <span class="keyword">let</span> <span class="variable declaration">x</span> = <span class="numeric_literal">92</span>;
+        <span class="keyword">let</span> <span class="variable declaration">x</span> <span class="punctuation">=</span> <span class="numeric_literal">92</span><span class="punctuation">;</span>
-        <span class="variable mutable">vec</span>.<span class="unresolved_reference">push</span>(<span class="struct">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="numeric_literal">1</span> });
+        <span class="variable mutable">vec</span><span class="punctuation">.</span><span class="unresolved_reference">push</span><span class="punctuation">(</span><span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="numeric_literal">1</span> <span class="punctuation">}</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    }
+    <span class="punctuation">}</span>
-    <span class="keyword unsafe">unsafe</span> {
+    <span class="keyword unsafe">unsafe</span> <span class="punctuation">{</span>
-        <span class="variable mutable">vec</span>.<span class="unresolved_reference">set_len</span>(<span class="numeric_literal">0</span>);
+        <span class="variable mutable">vec</span><span class="punctuation">.</span><span class="unresolved_reference">set_len</span><span class="punctuation">(</span><span class="numeric_literal">0</span><span class="punctuation">)</span><span class="punctuation">;</span>
-        <span class="static mutable">STATIC_MUT</span> = <span class="numeric_literal">1</span>;
+        <span class="static mutable">STATIC_MUT</span> <span class="punctuation">=</span> <span class="numeric_literal">1</span><span class="punctuation">;</span>
-    }
+    <span class="punctuation">}</span>
-    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> {
+    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> <span class="punctuation">{</span>
        <span class="comment">// Do nothing</span>
-    }
+    <span class="punctuation">}</span>
-    <span class="macro">noop!</span>(<span class="macro">noop</span><span class="macro">!</span>(<span class="numeric_literal">1</span>));
+    <span class="macro">noop!</span><span class="punctuation">(</span><span class="macro">noop</span><span class="macro">!</span><span class="punctuation">(</span><span class="numeric_literal">1</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> <span class="punctuation">=</span> <span class="numeric_literal">42</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
+    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> <span class="punctuation">=</span> <span class="punctuation">&</span><span class="keyword">mut</span> <span class="variable mutable">x</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
+    <span class="keyword">let</span> <span class="variable declaration">z</span> <span class="punctuation">=</span> <span class="punctuation">&</span><span class="variable mutable">y</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="struct">Foo</span> { <span class="field">x</span>: <span class="variable declaration">z</span>, <span class="field">y</span> } = <span class="struct">Foo</span> { <span class="field">x</span>: <span class="variable">z</span>, <span class="field">y</span> };
+    <span class="keyword">let</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">:</span> <span class="variable declaration">z</span><span class="punctuation">,</span> <span class="field">y</span> <span class="punctuation">}</span> <span class="punctuation">=</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">:</span> <span class="variable">z</span><span class="punctuation">,</span> <span class="field">y</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="variable">y</span>;
+    <span class="variable">y</span><span class="punctuation">;</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">enum</span> <span class="enum declaration">Option</span>&lt;<span class="type_param declaration">T</span>&gt; {
+<span class="keyword">enum</span> <span class="enum declaration">Option</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-    <span class="enum_variant declaration">Some</span>(<span class="type_param">T</span>),
+    <span class="enum_variant declaration">Some</span><span class="punctuation">(</span><span class="type_param">T</span><span class="punctuation">)</span><span class="punctuation">,</span>
-    <span class="enum_variant declaration">None</span>,
+    <span class="enum_variant declaration">None</span><span class="punctuation">,</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">use</span> <span class="enum">Option</span>::*;
+<span class="keyword">use</span> <span class="enum">Option</span><span class="punctuation">::</span>*<span class="punctuation">;</span>
-<span class="keyword">impl</span>&lt;<span class="type_param declaration">T</span>&gt; <span class="enum">Option</span>&lt;<span class="type_param">T</span>&gt; {
+<span class="keyword">impl</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration">and</span>&lt;<span class="type_param declaration">U</span>&gt;(<span class="self_keyword">self</span>, <span class="value_param declaration">other</span>: <span class="enum">Option</span>&lt;<span class="type_param">U</span>&gt;) -&gt; <span class="enum">Option</span>&lt;(<span class="type_param">T</span>, <span class="type_param">U</span>)&gt; {
+    <span class="keyword">fn</span> <span class="function declaration">and</span><span class="punctuation">&lt;</span><span class="type_param declaration">U</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">other</span><span class="punctuation">:</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">U</span><span class="punctuation">&gt;</span><span class="punctuation">)</span> <span class="punctuation">-&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="punctuation">(</span><span class="type_param">T</span><span class="punctuation">,</span> <span class="type_param">U</span><span class="punctuation">)</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-        <span class="keyword control">match</span> <span class="value_param">other</span> {
+        <span class="keyword control">match</span> <span class="value_param">other</span> <span class="punctuation">{</span>
-            <span class="enum_variant">None</span> =&gt; <span class="macro">unimplemented!</span>(),
+            <span class="enum_variant">None</span> <span class="punctuation">=&gt;</span> <span class="macro">unimplemented!</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
-            <span class="variable declaration">Nope</span> =&gt; <span class="variable">Nope</span>,
+            <span class="variable declaration">Nope</span> <span class="punctuation">=&gt;</span> <span class="variable">Nope</span><span class="punctuation">,</span>
-        }
+        <span class="punctuation">}</span>
-    }
+    <span class="punctuation">}</span>
-}</code></pre>
-\ No newline at end of file
+<span class="punctuation">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ra_ide/test_data/rainbow_highlighting.html b/crates/ra_ide/test_data/rainbow_highlighting.html
index 84a7686b2..2fed04a44 100644
--- a/crates/ra_ide/test_data/rainbow_highlighting.html
+++ b/crates/ra_ide/test_data/rainbow_highlighting.html
@@ -35,15 +35,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">fn</span> <span class="function declaration">main</span>() {
+<pre><code><span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string_literal">"hello"</span>;
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> <span class="punctuation">=</span> <span class="string_literal">"hello"</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="2705725358298919760" style="color: hsl(17,51%,74%);">x</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.<span class="unresolved_reference">to_string</span>();
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="2705725358298919760" style="color: hsl(17,51%,74%);">x</span> <span class="punctuation">=</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span><span class="punctuation">.</span><span class="unresolved_reference">to_string</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="3365759661443752373" style="color: hsl(127,76%,66%);">y</span> = <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span>.<span class="unresolved_reference">to_string</span>();
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="3365759661443752373" style="color: hsl(127,76%,66%);">y</span> <span class="punctuation">=</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span><span class="punctuation">.</span><span class="unresolved_reference">to_string</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span> = <span class="string_literal">"other color please!"</span>;
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span> <span class="punctuation">=</span> <span class="string_literal">"other color please!"</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="6717528807933952652" style="color: hsl(85,49%,84%);">y</span> = <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span>.<span class="unresolved_reference">to_string</span>();
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="6717528807933952652" style="color: hsl(85,49%,84%);">y</span> <span class="punctuation">=</span> <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(19,74%,76%);">x</span><span class="punctuation">.</span><span class="unresolved_reference">to_string</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-}
+<span class="punctuation">}</span>
-<span class="keyword">fn</span> <span class="function declaration">bar</span>() {
+<span class="keyword">fn</span> <span class="function declaration">bar</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> = <span class="string_literal">"hello"</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable" data-binding-hash="8121853618659664005" style="color: hsl(261,57%,61%);">hello</span> <span class="punctuation">=</span> <span class="string_literal">"hello"</span><span class="punctuation">;</span>
-}</code></pre>
-\ No newline at end of file
+<span class="punctuation">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index c3921bd40..bcddad60c 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_ide_db"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 3ef5e74b6..bcaabca92 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -255,8 +255,14 @@ pub fn classify_name_ref(
    }
    if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
-        if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
+        if let Some(path) = macro_call.path() {
-            return Some(NameRefClass::Definition(Definition::Macro(macro_def)));
+            if path.qualifier().is_none() {
+                // Only use this to resolve single-segment macro calls like `foo!()`. Multi-segment
+                // paths are handled below (allowing `log<|>::info!` to resolve to the log crate).
+                if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
+                    return Some(NameRefClass::Definition(Definition::Macro(macro_def)));
+                }
+            }
        }
    }
diff --git a/crates/ra_mbe/Cargo.toml b/crates/ra_mbe/Cargo.toml
index 4dec24914..a26746a19 100644
--- a/crates/ra_mbe/Cargo.toml
+++ b/crates/ra_mbe/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_mbe"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_parser/Cargo.toml b/crates/ra_parser/Cargo.toml
index 0da581fd5..72ec3e4d9 100644
--- a/crates/ra_parser/Cargo.toml
+++ b/crates/ra_parser/Cargo.toml
@@ -4,6 +4,7 @@ name = "ra_parser"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_proc_macro/Cargo.toml b/crates/ra_proc_macro/Cargo.toml
index d009ceb82..c4b6e9e7b 100644
--- a/crates/ra_proc_macro/Cargo.toml
+++ b/crates/ra_proc_macro/Cargo.toml
@@ -4,6 +4,7 @@ name = "ra_proc_macro"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_proc_macro_srv/Cargo.toml b/crates/ra_proc_macro_srv/Cargo.toml
index 582102945..12ce497f8 100644
--- a/crates/ra_proc_macro_srv/Cargo.toml
+++ b/crates/ra_proc_macro_srv/Cargo.toml
@@ -4,6 +4,7 @@ name = "ra_proc_macro_srv"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_prof/Cargo.toml b/crates/ra_prof/Cargo.toml
index eabfcebb0..b3d52985a 100644
--- a/crates/ra_prof/Cargo.toml
+++ b/crates/ra_prof/Cargo.toml
@@ -4,6 +4,7 @@ name = "ra_prof"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
@@ -12,6 +13,7 @@ doctest = false
 ra_arena = { path = "../ra_arena" }
 once_cell = "1.3.1"
 backtrace = { version = "0.3.44", optional = true }
+mimalloc = { version = "0.1.19", default-features = false, optional = true }
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 jemallocator = { version = "0.3.2", optional = true }
@@ -24,4 +26,5 @@ cpu_profiler = []
 # Uncomment to enable for the whole crate graph
 # default = [ "backtrace" ]
 # default = [ "jemalloc" ]
+# default = [ "mimalloc" ]
 # default = [ "cpu_profiler" ]
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 7163a8424..b54531b4e 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -19,6 +19,10 @@ pub use crate::{
 #[global_allocator]
 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
+#[cfg(all(feature = "mimalloc"))]
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
 /// Prints backtrace to stderr, useful for debugging.
 #[cfg(feature = "backtrace")]
 pub fn print_backtrace() {
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index b1b44dcf7..827eb7e28 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_project_model"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 940c30c7f..abc7a646c 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -189,6 +189,21 @@ impl ast::RecordFieldList {
    }
 }
+impl ast::TypeAliasDef {
+    #[must_use]
+    pub fn remove_bounds(&self) -> ast::TypeAliasDef {
+        let colon = match self.colon_token() {
+            Some(it) => it,
+            None => return self.clone(),
+        };
+        let end = match self.type_bound_list() {
+            Some(it) => it.syntax().clone().into(),
+            None => colon.clone().into(),
+        };
+        self.replace_children(colon.into()..=end, iter::empty())
+    }
+}
 impl ast::TypeParam {
    #[must_use]
    pub fn remove_bounds(&self) -> ast::TypeParam {
diff --git a/crates/ra_text_edit/Cargo.toml b/crates/ra_text_edit/Cargo.toml
index 46a2ab68f..dbb223350 100644
--- a/crates/ra_text_edit/Cargo.toml
+++ b/crates/ra_text_edit/Cargo.toml
@@ -4,6 +4,7 @@ name = "ra_text_edit"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 publish = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_toolchain/Cargo.toml b/crates/ra_toolchain/Cargo.toml
index 038c29ded..84b748c0a 100644
--- a/crates/ra_toolchain/Cargo.toml
+++ b/crates/ra_toolchain/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_toolchain"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/ra_tt/Cargo.toml b/crates/ra_tt/Cargo.toml
index b5b12e3af..3c45248c3 100644
--- a/crates/ra_tt/Cargo.toml
+++ b/crates/ra_tt/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_tt"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index c02f72517..57724bcbc 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -4,6 +4,7 @@ name = "rust-analyzer"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 autobins = false
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
@@ -65,3 +66,4 @@ tt = { path = "../ra_tt", package = "ra_tt" }
 [features]
 jemalloc = [ "ra_prof/jemalloc" ]
+mimalloc = [ "ra_prof/mimalloc" ]
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
index d0e566f47..3210416ee 100644
--- a/crates/rust-analyzer/src/bin/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -35,6 +35,7 @@ pub(crate) enum Command {
        with_proc_macro: bool,
    },
    Bench {
+        memory_usage: bool,
        path: PathBuf,
        what: BenchWhat,
        load_output_dirs: bool,
@@ -165,7 +166,7 @@ USAGE:
 FLAGS:
    -o, --only              Only analyze items matching this path
    -h, --help              Prints help information
-        --memory-usage      Collect memory usage statistics (requires `--feature jemalloc`)
+        --memory-usage      Collect memory usage statistics (requires `--features jemalloc`)
        --randomize         Randomize order in which crates, modules, and items are processed
        --parallel          Run type inference in parallel
        --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
@@ -220,6 +221,7 @@ USAGE:
 FLAGS:
    -h, --help          Prints help information
+    --memory-usage      Collect memory usage statistics (requires `--features jemalloc`)
    --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
    --with-proc-macro   Use ra-proc-macro-srv for proc-macro expanding
    -v, --verbose
@@ -251,9 +253,10 @@ ARGS:
                        "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
                    ),
                };
+                let memory_usage = matches.contains("--memory-usage");
                let load_output_dirs = matches.contains("--load-output-dirs");
                let with_proc_macro = matches.contains("--with-proc-macro");
-                Command::Bench { path, what, load_output_dirs, with_proc_macro }
+                Command::Bench { memory_usage, path, what, load_output_dirs, with_proc_macro }
            }
            "diagnostics" => {
                if matches.contains(["-h", "--help"]) {
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 65f1a6d15..408892eab 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -49,11 +49,12 @@ fn main() -> Result<()> {
            load_output_dirs,
            with_proc_macro,
        )?,
-        args::Command::Bench { path, what, load_output_dirs, with_proc_macro } => {
+        args::Command::Bench { memory_usage, path, what, load_output_dirs, with_proc_macro } => {
            cli::analysis_bench(
                args.verbosity,
                path.as_ref(),
                what,
+                memory_usage,
                load_output_dirs,
                with_proc_macro,
            )?
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index a93d5fb73..9299879b7 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -10,7 +10,10 @@ use ra_db::{
 use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CompletionConfig, FilePosition, LineCol};
 use vfs::AbsPathBuf;
-use crate::cli::{load_cargo::load_cargo, Verbosity};
+use crate::{
+    cli::{load_cargo::load_cargo, Verbosity},
+    print_memory_usage,
+};
 pub enum BenchWhat {
    Highlight { path: AbsPathBuf },
@@ -44,6 +47,7 @@ pub fn analysis_bench(
    verbosity: Verbosity,
    path: &Path,
    what: BenchWhat,
+    memory_usage: bool,
    load_output_dirs: bool,
    with_proc_macro: bool,
 ) -> Result<()> {
@@ -99,6 +103,11 @@ pub fn analysis_bench(
            }
        }
    }
+    if memory_usage {
+        print_memory_usage(host, vfs);
+    }
    Ok(())
 }
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 846264046..ddb3db6c3 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -21,7 +21,10 @@ use ra_db::{
 use ra_syntax::AstNode;
 use stdx::format_to;
-use crate::cli::{load_cargo::load_cargo, progress_report::ProgressReport, Result, Verbosity};
+use crate::{
+    cli::{load_cargo::load_cargo, progress_report::ProgressReport, Result, Verbosity},
+    print_memory_usage,
+};
 /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
 struct Snap<DB>(DB);
@@ -43,7 +46,7 @@ pub fn analysis_stats(
    with_proc_macro: bool,
 ) -> Result<()> {
    let db_load_time = Instant::now();
-    let (mut host, vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
+    let (host, vfs) = load_cargo(path, load_output_dirs, with_proc_macro)?;
    let db = host.raw_database();
    println!("Database loaded {:?}", db_load_time.elapsed());
    let analysis_time = Instant::now();
@@ -273,22 +276,7 @@ pub fn analysis_stats(
    println!("Total: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
    if memory_usage {
-        let mut mem = host.per_query_memory_usage();
+        print_memory_usage(host, vfs);
-        let before = ra_prof::memory_usage();
-        drop(vfs);
-        let vfs = before.allocated - ra_prof::memory_usage().allocated;
-        mem.push(("VFS".into(), vfs));
-        let before = ra_prof::memory_usage();
-        drop(host);
-        mem.push(("Unaccounted".into(), before.allocated - ra_prof::memory_usage().allocated));
-        mem.push(("Remaining".into(), ra_prof::memory_usage().allocated));
-        for (name, bytes) in mem {
-            println!("{:>8} {}", bytes, name)
-        }
    }
    Ok(())
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 9a9a6547a..94973b90a 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -63,7 +63,9 @@ pub(crate) struct GlobalState {
    req_queue: ReqQueue,
    pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
    pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
-    pub(crate) flycheck: Option<Handle<FlycheckHandle, Receiver<flycheck::Message>>>,
+    pub(crate) flycheck: Option<FlycheckHandle>,
+    pub(crate) flycheck_sender: Sender<flycheck::Message>,
+    pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
    pub(crate) config: Config,
    pub(crate) analysis_host: AnalysisHost,
    pub(crate) diagnostics: DiagnosticCollection,
@@ -103,12 +105,15 @@ impl GlobalState {
        };
        let analysis_host = AnalysisHost::new(config.lru_capacity);
+        let (flycheck_sender, flycheck_receiver) = unbounded();
        GlobalState {
            sender,
            req_queue: ReqQueue::default(),
            task_pool,
            loader,
            flycheck: None,
+            flycheck_sender,
+            flycheck_receiver,
            config,
            analysis_host,
            diagnostics: Default::default(),
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 407944d85..369830973 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -40,7 +40,9 @@ use serde::de::DeserializeOwned;
 pub type Result<T, E = Box<dyn std::error::Error + Send + Sync>> = std::result::Result<T, E>;
 pub use crate::{caps::server_capabilities, main_loop::main_loop};
+use ra_ide::AnalysisHost;
 use std::fmt;
+use vfs::Vfs;
 pub fn from_json<T: DeserializeOwned>(what: &'static str, json: serde_json::Value) -> Result<T> {
    let res = T::deserialize(&json)
@@ -67,3 +69,22 @@ impl fmt::Display for LspError {
 }
 impl std::error::Error for LspError {}
+fn print_memory_usage(mut host: AnalysisHost, vfs: Vfs) {
+    let mut mem = host.per_query_memory_usage();
+    let before = ra_prof::memory_usage();
+    drop(vfs);
+    let vfs = before.allocated - ra_prof::memory_usage().allocated;
+    mem.push(("VFS".into(), vfs));
+    let before = ra_prof::memory_usage();
+    drop(host);
+    mem.push(("Unaccounted".into(), before.allocated - ra_prof::memory_usage().allocated));
+    mem.push(("Remaining".into(), ra_prof::memory_usage().allocated));
+    for (name, bytes) in mem {
+        println!("{:>8} {}", bytes, name);
+    }
+}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 702f25a19..a41f7f564 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -5,7 +5,7 @@ use std::{
    time::{Duration, Instant},
 };
-use crossbeam_channel::{never, select, Receiver};
+use crossbeam_channel::{select, Receiver};
 use lsp_server::{Connection, Notification, Request, Response};
 use lsp_types::notification::Notification as _;
 use ra_db::VfsPath;
@@ -108,7 +108,7 @@ impl GlobalState {
            recv(self.loader.receiver) -> task =>
                Some(Event::Vfs(task.unwrap())),
-            recv(self.flycheck.as_ref().map_or(&never(), |it| &it.receiver)) -> task =>
+            recv(self.flycheck_receiver) -> task =>
                Some(Event::Flycheck(task.unwrap())),
        }
    }
@@ -122,29 +122,33 @@ impl GlobalState {
            );
        };
-        let registration_options = lsp_types::TextDocumentRegistrationOptions {
+        let save_registration_options = lsp_types::TextDocumentSaveRegistrationOptions {
-            document_selector: Some(vec![
+            include_text: Some(false),
-                lsp_types::DocumentFilter {
+            text_document_registration_options: lsp_types::TextDocumentRegistrationOptions {
-                    language: None,
+                document_selector: Some(vec![
-                    scheme: None,
+                    lsp_types::DocumentFilter {
-                    pattern: Some("**/*.rs".into()),
+                        language: None,
-                },
+                        scheme: None,
-                lsp_types::DocumentFilter {
+                        pattern: Some("**/*.rs".into()),
-                    language: None,
+                    },
-                    scheme: None,
+                    lsp_types::DocumentFilter {
-                    pattern: Some("**/Cargo.toml".into()),
+                        language: None,
-                },
+                        scheme: None,
-                lsp_types::DocumentFilter {
+                        pattern: Some("**/Cargo.toml".into()),
-                    language: None,
+                    },
-                    scheme: None,
+                    lsp_types::DocumentFilter {
-                    pattern: Some("**/Cargo.lock".into()),
+                        language: None,
-                },
+                        scheme: None,
-            ]),
+                        pattern: Some("**/Cargo.lock".into()),
+                    },
+                ]),
+            },
        };
        let registration = lsp_types::Registration {
            id: "textDocument/didSave".to_string(),
            method: "textDocument/didSave".to_string(),
-            register_options: Some(serde_json::to_value(registration_options).unwrap()),
+            register_options: Some(serde_json::to_value(save_registration_options).unwrap()),
        };
        self.send_request::<lsp_types::request::RegisterCapability>(
            lsp_types::RegistrationParams { registrations: vec![registration] },
@@ -288,7 +292,7 @@ impl GlobalState {
        let state_changed = self.process_changes();
        if prev_status == Status::Loading && self.status == Status::Ready {
            if let Some(flycheck) = &self.flycheck {
-                flycheck.handle.update();
+                flycheck.update();
            }
        }
@@ -437,7 +441,7 @@ impl GlobalState {
            })?
            .on::<lsp_types::notification::DidSaveTextDocument>(|this, params| {
                if let Some(flycheck) = &this.flycheck {
-                    flycheck.handle.update();
+                    flycheck.update();
                }
                if let Ok(abs_path) = from_proto::abs_path(&params.text_document.uri) {
                    this.maybe_refresh(&[(abs_path, ChangeKind::Modify)]);
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index ab1b18ea9..3f4dbdd8c 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -1,20 +1,19 @@
 //! Project loading & configuration updates
 use std::{mem, sync::Arc};
-use crossbeam_channel::unbounded;
 use flycheck::FlycheckHandle;
 use ra_db::{CrateGraph, SourceRoot, VfsPath};
 use ra_ide::AnalysisChange;
+use ra_prof::profile;
 use ra_project_model::{PackageRoot, ProcMacroClient, ProjectWorkspace};
 use vfs::{file_set::FileSetConfig, AbsPath, AbsPathBuf, ChangeKind};
 use crate::{
    config::{Config, FilesWatcher, LinkedProject},
-    global_state::{GlobalState, Handle, Status},
+    global_state::{GlobalState, Status},
    lsp_ext,
    main_loop::Task,
 };
-use ra_prof::profile;
 impl GlobalState {
    pub(crate) fn update_configuration(&mut self, config: Config) {
@@ -231,21 +230,20 @@ impl GlobalState {
            }
        };
-        // FIXME: Figure out the multi-workspace situation
+        let sender = self.flycheck_sender.clone();
-        self.flycheck = self.workspaces.iter().find_map(move |w| match w {
+        let sender = Box::new(move |msg| sender.send(msg).unwrap());
-            ProjectWorkspace::Cargo { cargo, .. } => {
+        self.flycheck = self
-                let (sender, receiver) = unbounded();
+            .workspaces
-                let sender = Box::new(move |msg| sender.send(msg).unwrap());
+            .iter()
+            // FIXME: Figure out the multi-workspace situation
+            .find_map(|w| match w {
+                ProjectWorkspace::Cargo { cargo, sysroot: _ } => Some(cargo),
+                ProjectWorkspace::Json { .. } => None,
+            })
+            .map(move |cargo| {
                let cargo_project_root = cargo.workspace_root().to_path_buf();
-                let handle =
+                FlycheckHandle::spawn(sender, config.clone(), cargo_project_root.into())
-                    FlycheckHandle::spawn(sender, config.clone(), cargo_project_root.into());
+            })
-                Some(Handle { handle, receiver })
-            }
-            ProjectWorkspace::Json { .. } => {
-                log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
-                None
-            }
-        })
    }
 }
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 10fe40cb5..576bd8adc 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -43,6 +43,7 @@ define_semantic_token_types![
    (FORMAT_SPECIFIER, "formatSpecifier"),
    (GENERIC, "generic"),
    (LIFETIME, "lifetime"),
+    (PUNCTUATION, "punctuation"),
    (SELF_KEYWORD, "selfKeyword"),
    (TYPE_ALIAS, "typeAlias"),
    (UNION, "union"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 3585202a4..2fcae9ca3 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -327,6 +327,7 @@ fn semantic_token_type_and_modifiers(
        HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
        HighlightTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
        HighlightTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
+        HighlightTag::Punctuation => semantic_tokens::PUNCTUATION,
    };
    for modifier in highlight.modifiers.iter() {
diff --git a/crates/stdx/Cargo.toml b/crates/stdx/Cargo.toml
index f9e380c10..4c0b85861 100644
--- a/crates/stdx/Cargo.toml
+++ b/crates/stdx/Cargo.toml
@@ -3,6 +3,7 @@ name = "stdx"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 edition = "2018"
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/test_utils/Cargo.toml b/crates/test_utils/Cargo.toml
index 6821db1e8..e719f4f7c 100644
--- a/crates/test_utils/Cargo.toml
+++ b/crates/test_utils/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "test_utils"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index e4aa894ac..ad586c882 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -179,31 +179,80 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
    let mut res = Vec::new();
    let mut prev_line_start: Option<TextSize> = None;
    let mut line_start: TextSize = 0.into();
+    let mut prev_line_annotations: Vec<(TextSize, usize)> = Vec::new();
    for line in lines_with_ends(text) {
-        if let Some(idx) = line.find("//^") {
+        let mut this_line_annotations = Vec::new();
-            let offset = prev_line_start.unwrap() + TextSize::of(&line[..idx + "//".len()]);
+        if let Some(idx) = line.find("//") {
-            for (line_range, text) in extract_line_annotations(&line[idx + "//".len()..]) {
+            let annotation_offset = TextSize::of(&line[..idx + "//".len()]);
-                res.push((line_range + offset, text))
+            for annotation in extract_line_annotations(&line[idx + "//".len()..]) {
+                match annotation {
+                    LineAnnotation::Annotation { mut range, content } => {
+                        range += annotation_offset;
+                        this_line_annotations.push((range.end(), res.len()));
+                        res.push((range + prev_line_start.unwrap(), content))
+                    }
+                    LineAnnotation::Continuation { mut offset, content } => {
+                        offset += annotation_offset;
+                        let &(_, idx) = prev_line_annotations
+                            .iter()
+                            .find(|&&(off, _idx)| off == offset)
+                            .unwrap();
+                        res[idx].1.push('\n');
+                        res[idx].1.push_str(&content);
+                        res[idx].1.push('\n');
+                    }
+                }
            }
        }
        prev_line_start = Some(line_start);
        line_start += TextSize::of(line);
+        prev_line_annotations = this_line_annotations;
    }
    res
 }
-fn extract_line_annotations(mut line: &str) -> Vec<(TextRange, String)> {
+enum LineAnnotation {
+    Annotation { range: TextRange, content: String },
+    Continuation { offset: TextSize, content: String },
+}
+fn extract_line_annotations(mut line: &str) -> Vec<LineAnnotation> {
    let mut res = Vec::new();
    let mut offset: TextSize = 0.into();
-    while !line.is_empty() {
+    let marker: fn(char) -> bool = if line.contains('^') { |c| c == '^' } else { |c| c == '|' };
-        let len = line.chars().take_while(|&it| it == '^').count();
+    loop {
-        assert!(len > 0);
+        match line.find(marker) {
+            Some(idx) => {
+                offset += TextSize::try_from(idx).unwrap();
+                line = &line[idx..];
+            }
+            None => break,
+        };
+        let mut len = line.chars().take_while(|&it| it == '^').count();
+        let mut continuation = false;
+        if len == 0 {
+            assert!(line.starts_with('|'));
+            continuation = true;
+            len = 1;
+        }
        let range = TextRange::at(offset, len.try_into().unwrap());
-        let next = line[len..].find('^').map_or(line.len(), |it| it + len);
+        let next = line[len..].find(marker).map_or(line.len(), |it| it + len);
-        res.push((range, line[len..][..next - len].trim().to_string()));
+        let content = line[len..][..next - len].trim().to_string();
+        let annotation = if continuation {
+            LineAnnotation::Continuation { offset: range.end(), content }
+        } else {
+            LineAnnotation::Annotation { range, content }
+        };
+        res.push(annotation);
        line = &line[next..];
        offset += TextSize::try_from(next).unwrap();
    }
    res
 }
@@ -215,14 +264,18 @@ fn main() {
    let (x,     y) = (9, 2);
       //^ def  ^ def
    zoo + 1
-} //^^^ i32
+} //^^^ type:
+  //  | i32
    "#,
    );
    let res = extract_annotations(&text)
        .into_iter()
        .map(|(range, ann)| (&text[range], ann))
        .collect::<Vec<_>>();
-    assert_eq!(res, vec![("x", "def".into()), ("y", "def".into()), ("zoo", "i32".into()),]);
+    assert_eq!(
+        res,
+        vec![("x", "def".into()), ("y", "def".into()), ("zoo", "type:\ni32\n".into()),]
+    );
 }
 // Comparison functionality borrowed from cargo:
diff --git a/crates/test_utils/src/mark.rs b/crates/test_utils/src/mark.rs
index 7c309a894..97f5a93ad 100644
--- a/crates/test_utils/src/mark.rs
+++ b/crates/test_utils/src/mark.rs
@@ -62,7 +62,7 @@ pub struct MarkChecker {
 impl MarkChecker {
    pub fn new(mark: &'static AtomicUsize) -> MarkChecker {
-        let value_on_entry = mark.load(Ordering::SeqCst);
+        let value_on_entry = mark.load(Ordering::Relaxed);
        MarkChecker { mark, value_on_entry }
    }
 }
@@ -72,7 +72,7 @@ impl Drop for MarkChecker {
        if std::thread::panicking() {
            return;
        }
-        let value_on_exit = self.mark.load(Ordering::SeqCst);
+        let value_on_exit = self.mark.load(Ordering::Relaxed);
        assert!(value_on_exit > self.value_on_entry, "mark was not hit")
    }
 }
diff --git a/crates/vfs-notify/Cargo.toml b/crates/vfs-notify/Cargo.toml
index eb1764c36..95c56ffa6 100644
--- a/crates/vfs-notify/Cargo.toml
+++ b/crates/vfs-notify/Cargo.toml
@@ -3,6 +3,7 @@ name = "vfs-notify"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 edition = "2018"
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/vfs/Cargo.toml b/crates/vfs/Cargo.toml
index db99707b3..b74cdb7ff 100644
--- a/crates/vfs/Cargo.toml
+++ b/crates/vfs/Cargo.toml
@@ -3,6 +3,7 @@ name = "vfs"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 edition = "2018"
+license = "MIT OR Apache-2.0"
 [lib]
 doctest = false
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 37c479306..e5e2ef530 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -62,7 +62,7 @@ impl FileSetConfig {
        let mut res = vec![FileSet::default(); self.len()];
        for (file_id, path) in vfs.iter() {
            let root = self.classify(&path, &mut scratch_space);
-            res[root].insert(file_id, path)
+            res[root].insert(file_id, path.clone())
        }
        res
    }
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
index 3bfecd08f..cdf6f1fd0 100644
--- a/crates/vfs/src/lib.rs
+++ b/crates/vfs/src/lib.rs
@@ -90,12 +90,12 @@ impl Vfs {
    pub fn file_contents(&self, file_id: FileId) -> &[u8] {
        self.get(file_id).as_deref().unwrap()
    }
-    pub fn iter(&self) -> impl Iterator<Item = (FileId, VfsPath)> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = (FileId, &VfsPath)> + '_ {
        (0..self.data.len())
            .map(|it| FileId(it as u32))
            .filter(move |&file_id| self.get(file_id).is_some())
            .map(move |file_id| {
-                let path = self.interner.lookup(file_id).clone();
+                let path = self.interner.lookup(file_id);
                (file_id, path)
            })
    }