121 files changed, 3733 insertions, 1269 deletions

diff --git a/Cargo.lock b/Cargo.lock
index e3ad50623..efe8dd189 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,9 +11,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.26"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7825f6833612eb2414095684fcf6c635becf3ce97fe48cf6421321e93bfbd53c"
+checksum = "013a6e0a2cbe3d20f9c60b65458f7a7f7a5e636c5d0f45a5a6aee5d4b1f01785"
 
 [[package]]
 name = "anymap"
@@ -58,9 +58,9 @@ dependencies = [
 
 [[package]]
 name = "backtrace-sys"
-version = "0.1.33"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e17b52e737c40a7d75abca20b29a19a0eb7ba9fc72c5a72dd282a0a3c2c0dc35"
+checksum = "ca797db0057bae1a7aa2eef3283a874695455cecf08a43bfb8507ee0ebc1ed69"
 dependencies = [
  "cc",
  "libc",
@@ -80,29 +80,14 @@ checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
 
 [[package]]
 name = "bstr"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "502ae1441a0a5adb8fbd38a5955a6416b9493e92b465de5e4a9bde6a539c2c48"
+checksum = "2889e6d50f394968c8bf4240dc3f2a7eb4680844d27308f798229ac9d4725f41"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "byteorder"
-version = "1.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
-
-[[package]]
-name = "c2-chacha"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb"
-dependencies = [
- "ppv-lite86",
-]
-
-[[package]]
 name = "cargo_metadata"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -401,12 +386,9 @@ dependencies = [
 
 [[package]]
 name = "fst"
-version = "0.3.5"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "927fb434ff9f0115b215dc0efd2e4fbdd7448522a92a1aa37c77d6a2f8f1ebd6"
-dependencies = [
- "byteorder",
-]
+checksum = "3f7c13470d799474d44e2b9c6a0925807def7af4d120cd4de761433be76f7579"
 
 [[package]]
 name = "fuchsia-zircon"
@@ -958,6 +940,7 @@ dependencies = [
 name = "ra_hir"
 version = "0.1.0"
 dependencies = [
+ "arrayvec",
  "either",
  "itertools",
  "log",
@@ -1180,11 +1163,11 @@ dependencies = [
 
 [[package]]
 name = "rand_chacha"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 dependencies = [
- "c2-chacha",
+ "ppv-lite86",
  "rand_core",
 ]
 
@@ -1247,9 +1230,9 @@ checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
 
 [[package]]
 name = "regex"
-version = "1.3.4"
+version = "1.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322cf97724bea3ee221b78fe25ac9c46114ebb51747ad5babd51a2fc6a8235a8"
+checksum = "8900ebc1363efa7ea1c399ccc32daed870b4002651e0bed86e72d501ebbe0048"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1259,9 +1242,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.16"
+version = "0.6.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1132f845907680735a84409c3bebc64d1364a5683ffbce899550cd09d5eaefc1"
+checksum = "7fe5bd57d1d7414c6b5ed48563a2c855d995ff777729dcd91c369ec7fea395ae"
 
 [[package]]
 name = "relative-path"
@@ -1359,9 +1342,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa8506c1de11c9c4e4c38863ccbe02a305c8188e85a05a784c9e11e1c3910c8"
+checksum = "535622e6be132bccd223f4bb2b8ac8d53cda3c7a6394944d3b2b33fb974f9d76"
 
 [[package]]
 name = "salsa"
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 42856f0ca..45558c448 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -37,7 +37,6 @@ pub struct SubstituteTypeParams<'a> {
 impl<'a> SubstituteTypeParams<'a> {
     pub fn for_trait_impl(
         source_scope: &'a SemanticsScope<'a, RootDatabase>,
-        db: &'a RootDatabase,
         // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
         trait_: hir::Trait,
         impl_def: ast::ImplDef,
@@ -45,7 +44,7 @@ impl<'a> SubstituteTypeParams<'a> {
         let substs = get_syntactic_substs(impl_def).unwrap_or_default();
         let generic_def: hir::GenericDef = trait_.into();
         let substs_by_param: FxHashMap<_, _> = generic_def
-            .params(db)
+            .params(source_scope.db)
             .into_iter()
             // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky
             .skip(1)
@@ -104,7 +103,6 @@ impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
 pub struct QualifyPaths<'a> {
     target_scope: &'a SemanticsScope<'a, RootDatabase>,
     source_scope: &'a SemanticsScope<'a, RootDatabase>,
-    db: &'a RootDatabase,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
@@ -112,9 +110,8 @@ impl<'a> QualifyPaths<'a> {
     pub fn new(
         target_scope: &'a SemanticsScope<'a, RootDatabase>,
         source_scope: &'a SemanticsScope<'a, RootDatabase>,
-        db: &'a RootDatabase,
     ) -> Self {
-        Self { target_scope, source_scope, db, previous: Box::new(NullTransformer) }
+        Self { target_scope, source_scope, previous: Box::new(NullTransformer) }
     }
 
     fn get_substitution_inner(
@@ -132,7 +129,7 @@ impl<'a> QualifyPaths<'a> {
         let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
         match resolution {
             PathResolution::Def(def) => {
-                let found_path = from.find_use_path(self.db, def)?;
+                let found_path = from.find_use_path(self.source_scope.db, def)?;
                 let mut path = path_to_ast(found_path);
 
                 let type_args = p
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 639180d37..e5920b6f6 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -142,8 +142,8 @@ fn add_missing_impl_members_inner(
         let n_existing_items = impl_item_list.impl_items().count();
         let source_scope = sema.scope_for_def(trait_);
         let target_scope = sema.scope(impl_item_list.syntax());
-        let ast_transform = QualifyPaths::new(&target_scope, &source_scope, sema.db)
-            .or(SubstituteTypeParams::for_trait_impl(&source_scope, sema.db, trait_, impl_node));
+        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_node));
         let items = missing_items
             .into_iter()
             .map(|it| ast_transform::apply(&*ast_transform, it))
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index e5d8c639d..97cf90ae4 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -2,7 +2,7 @@
 
 use std::iter;
 
-use hir::{db::HirDatabase, Adt, HasSource, Semantics};
+use hir::{Adt, HasSource, Semantics};
 use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -88,11 +88,7 @@ fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
     })
 }
 
-fn build_pat(
-    db: &impl HirDatabase,
-    module: hir::Module,
-    var: hir::EnumVariant,
-) -> Option<ast::Pat> {
+fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
     let path = crate::ast_transform::path_to_ast(module.find_use_path(db, var.into())?);
 
     // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 50a15f978..62fadcddd 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -235,7 +235,7 @@ mod helpers {
             (Some(assist), ExpectedResult::Target(target)) => {
                 let action = assist.0[0].action.clone().unwrap();
                 let range = action.target.expect("expected target on action");
-                assert_eq_text!(&before[range.start().to_usize()..range.end().to_usize()], target);
+                assert_eq_text!(&before[range], target);
             }
             (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
             (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_cargo_watch/src/conv.rs
index 0246adfb5..c6f8ca329 100644
--- a/crates/ra_cargo_watch/src/conv.rs
+++ b/crates/ra_cargo_watch/src/conv.rs
@@ -8,6 +8,7 @@ use lsp_types::{
     Location, NumberOrString, Position, Range, TextEdit, Url, WorkspaceEdit,
 };
 use std::{
+    collections::HashMap,
     fmt::Write,
     path::{Component, Path, PathBuf, Prefix},
     str::FromStr,
@@ -126,44 +127,34 @@ fn map_rust_child_diagnostic(
     rd: &RustDiagnostic,
     workspace_root: &PathBuf,
 ) -> MappedRustChildDiagnostic {
-    let span: &DiagnosticSpan = match rd.spans.iter().find(|s| s.is_primary) {
-        Some(span) => span,
-        None => {
-            // `rustc` uses these spanless children as a way to print multi-line
-            // messages
-            return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
+    let spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
+    if spans.is_empty() {
+        // `rustc` uses these spanless children as a way to print multi-line
+        // messages
+        return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
+    }
+
+    let mut edit_map: HashMap<Url, Vec<TextEdit>> = HashMap::new();
+    for &span in &spans {
+        if let Some(suggested_replacement) = &span.suggested_replacement {
+            let location = map_span_to_location(span, workspace_root);
+            let edit = TextEdit::new(location.range, suggested_replacement.clone());
+            edit_map.entry(location.uri).or_default().push(edit);
         }
-    };
-
-    // If we have a primary span use its location, otherwise use the parent
-    let location = map_span_to_location(&span, workspace_root);
-
-    if let Some(suggested_replacement) = &span.suggested_replacement {
-        // Include our replacement in the title unless it's empty
-        let title = if !suggested_replacement.is_empty() {
-            format!("{}: '{}'", rd.message, suggested_replacement)
-        } else {
-            rd.message.clone()
-        };
-
-        let edit = {
-            let edits = vec![TextEdit::new(location.range, suggested_replacement.clone())];
-            let mut edit_map = std::collections::HashMap::new();
-            edit_map.insert(location.uri, edits);
-            WorkspaceEdit::new(edit_map)
-        };
+    }
 
+    if !edit_map.is_empty() {
         MappedRustChildDiagnostic::SuggestedFix(CodeAction {
-            title,
+            title: rd.message.clone(),
             kind: Some("quickfix".to_string()),
             diagnostics: None,
-            edit: Some(edit),
+            edit: Some(WorkspaceEdit::new(edit_map)),
             command: None,
             is_preferred: None,
         })
     } else {
         MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
-            location,
+            location: map_span_to_location(spans[0], workspace_root),
             message: rd.message.clone(),
         })
     }
@@ -189,13 +180,13 @@ pub(crate) struct MappedRustDiagnostic {
 pub(crate) fn map_rust_diagnostic_to_lsp(
     rd: &RustDiagnostic,
     workspace_root: &PathBuf,
-) -> Option<MappedRustDiagnostic> {
-    let primary_span = rd.spans.iter().find(|s| s.is_primary)?;
-
-    let location = map_span_to_location(&primary_span, workspace_root);
+) -> Vec<MappedRustDiagnostic> {
+    let primary_spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
+    if primary_spans.is_empty() {
+        return vec![];
+    }
 
     let severity = map_level_to_severity(rd.level);
-    let mut primary_span_label = primary_span.label.as_ref();
 
     let mut source = String::from("rustc");
     let mut code = rd.code.as_ref().map(|c| c.code.clone());
@@ -208,19 +199,10 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
         }
     }
 
+    let mut needs_primary_span_label = true;
     let mut related_information = vec![];
     let mut tags = vec![];
 
-    // If error occurs from macro expansion, add related info pointing to
-    // where the error originated
-    if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
-        let def_loc = map_span_to_location_naive(&primary_span, workspace_root);
-        related_information.push(DiagnosticRelatedInformation {
-            location: def_loc,
-            message: "Error originated from macro here".to_string(),
-        });
-    }
-
     for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
         let related = map_secondary_span_to_related(secondary_span, workspace_root);
         if let Some(related) = related {
@@ -240,15 +222,11 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
 
                 // These secondary messages usually duplicate the content of the
                 // primary span label.
-                primary_span_label = None;
+                needs_primary_span_label = false;
             }
         }
     }
 
-    if let Some(primary_span_label) = primary_span_label {
-        write!(&mut message, "\n{}", primary_span_label).unwrap();
-    }
-
     if is_unused_or_unnecessary(rd) {
         tags.push(DiagnosticTag::Unnecessary);
     }
@@ -257,21 +235,45 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
         tags.push(DiagnosticTag::Deprecated);
     }
 
-    let diagnostic = Diagnostic {
-        range: location.range,
-        severity,
-        code: code.map(NumberOrString::String),
-        source: Some(source),
-        message,
-        related_information: if !related_information.is_empty() {
-            Some(related_information)
-        } else {
-            None
-        },
-        tags: if !tags.is_empty() { Some(tags) } else { None },
-    };
-
-    Some(MappedRustDiagnostic { location, diagnostic, fixes })
+    primary_spans
+        .iter()
+        .map(|primary_span| {
+            let location = map_span_to_location(&primary_span, workspace_root);
+
+            let mut message = message.clone();
+            if needs_primary_span_label {
+                if let Some(primary_span_label) = &primary_span.label {
+                    write!(&mut message, "\n{}", primary_span_label).unwrap();
+                }
+            }
+
+            // If error occurs from macro expansion, add related info pointing to
+            // where the error originated
+            if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
+                let def_loc = map_span_to_location_naive(&primary_span, workspace_root);
+                related_information.push(DiagnosticRelatedInformation {
+                    location: def_loc,
+                    message: "Error originated from macro here".to_string(),
+                });
+            }
+
+            let diagnostic = Diagnostic {
+                range: location.range,
+                severity,
+                code: code.clone().map(NumberOrString::String),
+                source: Some(source.clone()),
+                message,
+                related_information: if !related_information.is_empty() {
+                    Some(related_information.clone())
+                } else {
+                    None
+                },
+                tags: if !tags.is_empty() { Some(tags.clone()) } else { None },
+            };
+
+            MappedRustDiagnostic { location, diagnostic, fixes: fixes.clone() }
+        })
+        .collect()
 }
 
 /// Returns a `Url` object from a given path, will lowercase drive letters if present.
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
index 95ca163dc..9e8f4eff4 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
@@ -2,98 +2,100 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/compiler/mir/tagset.rs",
-        range: Range {
-            start: Position {
-                line: 41,
-                character: 23,
-            },
-            end: Position {
-                line: 41,
-                character: 28,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/compiler/mir/tagset.rs",
+            range: Range {
+                start: Position {
+                    line: 41,
+                    character: 23,
+                },
+                end: Position {
+                    line: 41,
+                    character: 28,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 41,
-                character: 23,
-            },
-            end: Position {
-                line: 41,
-                character: 28,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 41,
+                    character: 23,
+                },
+                end: Position {
+                    line: 41,
+                    character: 28,
+                },
             },
-        },
-        severity: Some(
-            Warning,
-        ),
-        code: Some(
-            String(
-                "trivially_copy_pass_by_ref",
+            severity: Some(
+                Warning,
             ),
-        ),
-        source: Some(
-            "clippy",
-        ),
-        message: "this argument is passed by reference, but would be more efficient if passed by value\n#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
-        related_information: Some(
-            [
-                DiagnosticRelatedInformation {
-                    location: Location {
-                        uri: "file:///test/compiler/lib.rs",
-                        range: Range {
-                            start: Position {
-                                line: 0,
-                                character: 8,
-                            },
-                            end: Position {
-                                line: 0,
-                                character: 19,
+            code: Some(
+                String(
+                    "trivially_copy_pass_by_ref",
+                ),
+            ),
+            source: Some(
+                "clippy",
+            ),
+            message: "this argument is passed by reference, but would be more efficient if passed by value\n#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
+            related_information: Some(
+                [
+                    DiagnosticRelatedInformation {
+                        location: Location {
+                            uri: "file:///test/compiler/lib.rs",
+                            range: Range {
+                                start: Position {
+                                    line: 0,
+                                    character: 8,
+                                },
+                                end: Position {
+                                    line: 0,
+                                    character: 19,
+                                },
                             },
                         },
+                        message: "lint level defined here",
                     },
-                    message: "lint level defined here",
-                },
-            ],
-        ),
-        tags: None,
-    },
-    fixes: [
-        CodeAction {
-            title: "consider passing by value instead: \'self\'",
-            kind: Some(
-                "quickfix",
+                ],
             ),
-            diagnostics: None,
-            edit: Some(
-                WorkspaceEdit {
-                    changes: Some(
-                        {
-                            "file:///test/compiler/mir/tagset.rs": [
-                                TextEdit {
-                                    range: Range {
-                                        start: Position {
-                                            line: 41,
-                                            character: 23,
-                                        },
-                                        end: Position {
-                                            line: 41,
-                                            character: 28,
+            tags: None,
+        },
+        fixes: [
+            CodeAction {
+                title: "consider passing by value instead",
+                kind: Some(
+                    "quickfix",
+                ),
+                diagnostics: None,
+                edit: Some(
+                    WorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/compiler/mir/tagset.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 41,
+                                                character: 23,
+                                            },
+                                            end: Position {
+                                                line: 41,
+                                                character: 28,
+                                            },
                                         },
+                                        new_text: "self",
                                     },
-                                    new_text: "self",
-                                },
-                            ],
-                        },
-                    ),
-                    document_changes: None,
-                },
-            ),
-            command: None,
-            is_preferred: None,
-        },
-    ],
-}
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+                command: None,
+                is_preferred: None,
+            },
+        ],
+    },
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
index 12eb32df4..61ae0c9ae 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
@@ -2,45 +2,47 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/src/main.rs",
-        range: Range {
-            start: Position {
-                line: 1,
-                character: 4,
-            },
-            end: Position {
-                line: 1,
-                character: 26,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/src/main.rs",
+            range: Range {
+                start: Position {
+                    line: 1,
+                    character: 4,
+                },
+                end: Position {
+                    line: 1,
+                    character: 26,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 1,
-                character: 4,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 1,
+                    character: 4,
+                },
+                end: Position {
+                    line: 1,
+                    character: 26,
+                },
             },
-            end: Position {
-                line: 1,
-                character: 26,
-            },
-        },
-        severity: Some(
-            Error,
-        ),
-        code: Some(
-            String(
-                "E0277",
+            severity: Some(
+                Error,
             ),
-        ),
-        source: Some(
-            "rustc",
-        ),
-        message: "can\'t compare `{integer}` with `&str`\nthe trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
-        related_information: None,
-        tags: None,
+            code: Some(
+                String(
+                    "E0277",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "can\'t compare `{integer}` with `&str`\nthe trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
+            related_information: None,
+            tags: None,
+        },
+        fixes: [],
     },
-    fixes: [],
-}
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
index 7b83a7cd0..641da1a58 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
@@ -2,60 +2,62 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/crates/ra_hir_def/src/data.rs",
-        range: Range {
-            start: Position {
-                line: 79,
-                character: 15,
-            },
-            end: Position {
-                line: 79,
-                character: 41,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/crates/ra_hir_def/src/data.rs",
+            range: Range {
+                start: Position {
+                    line: 79,
+                    character: 15,
+                },
+                end: Position {
+                    line: 79,
+                    character: 41,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 79,
-                character: 15,
-            },
-            end: Position {
-                line: 79,
-                character: 41,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 79,
+                    character: 15,
+                },
+                end: Position {
+                    line: 79,
+                    character: 41,
+                },
             },
-        },
-        severity: Some(
-            Error,
-        ),
-        code: None,
-        source: Some(
-            "rustc",
-        ),
-        message: "Please register your known path in the path module",
-        related_information: Some(
-            [
-                DiagnosticRelatedInformation {
-                    location: Location {
-                        uri: "file:///test/crates/ra_hir_def/src/path.rs",
-                        range: Range {
-                            start: Position {
-                                line: 264,
-                                character: 8,
-                            },
-                            end: Position {
-                                line: 264,
-                                character: 76,
+            severity: Some(
+                Error,
+            ),
+            code: None,
+            source: Some(
+                "rustc",
+            ),
+            message: "Please register your known path in the path module",
+            related_information: Some(
+                [
+                    DiagnosticRelatedInformation {
+                        location: Location {
+                            uri: "file:///test/crates/ra_hir_def/src/path.rs",
+                            range: Range {
+                                start: Position {
+                                    line: 264,
+                                    character: 8,
+                                },
+                                end: Position {
+                                    line: 264,
+                                    character: 76,
+                                },
                             },
                         },
+                        message: "Error originated from macro here",
                     },
-                    message: "Error originated from macro here",
-                },
-            ],
-        ),
-        tags: None,
+                ],
+            ),
+            tags: None,
+        },
+        fixes: [],
     },
-    fixes: [],
-}
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap
new file mode 100644
index 000000000..0557a2e79
--- /dev/null
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap
@@ -0,0 +1,114 @@
+---
+source: crates/ra_cargo_watch/src/conv/test.rs
+expression: diag
+---
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/src/main.rs",
+            range: Range {
+                start: Position {
+                    line: 3,
+                    character: 4,
+                },
+                end: Position {
+                    line: 3,
+                    character: 5,
+                },
+            },
+        },
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 3,
+                    character: 4,
+                },
+                end: Position {
+                    line: 3,
+                    character: 5,
+                },
+            },
+            severity: Some(
+                Warning,
+            ),
+            code: Some(
+                String(
+                    "let_and_return",
+                ),
+            ),
+            source: Some(
+                "clippy",
+            ),
+            message: "returning the result of a let binding from a block\n`#[warn(clippy::let_and_return)]` on by default\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return",
+            related_information: Some(
+                [
+                    DiagnosticRelatedInformation {
+                        location: Location {
+                            uri: "file:///test/src/main.rs",
+                            range: Range {
+                                start: Position {
+                                    line: 2,
+                                    character: 4,
+                                },
+                                end: Position {
+                                    line: 2,
+                                    character: 30,
+                                },
+                            },
+                        },
+                        message: "unnecessary let binding",
+                    },
+                ],
+            ),
+            tags: None,
+        },
+        fixes: [
+            CodeAction {
+                title: "return the expression directly",
+                kind: Some(
+                    "quickfix",
+                ),
+                diagnostics: None,
+                edit: Some(
+                    WorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/src/main.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 2,
+                                                character: 4,
+                                            },
+                                            end: Position {
+                                                line: 2,
+                                                character: 30,
+                                            },
+                                        },
+                                        new_text: "",
+                                    },
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 3,
+                                                character: 4,
+                                            },
+                                            end: Position {
+                                                line: 3,
+                                                character: 5,
+                                            },
+                                        },
+                                        new_text: "(0..10).collect()",
+                                    },
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+                command: None,
+                is_preferred: None,
+            },
+        ],
+    },
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
index 54679c5db..754bc33a4 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
@@ -2,45 +2,47 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/compiler/ty/list_iter.rs",
-        range: Range {
-            start: Position {
-                line: 51,
-                character: 4,
-            },
-            end: Position {
-                line: 51,
-                character: 47,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/compiler/ty/list_iter.rs",
+            range: Range {
+                start: Position {
+                    line: 51,
+                    character: 4,
+                },
+                end: Position {
+                    line: 51,
+                    character: 47,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 51,
-                character: 4,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 51,
+                    character: 4,
+                },
+                end: Position {
+                    line: 51,
+                    character: 47,
+                },
             },
-            end: Position {
-                line: 51,
-                character: 47,
-            },
-        },
-        severity: Some(
-            Error,
-        ),
-        code: Some(
-            String(
-                "E0053",
+            severity: Some(
+                Error,
             ),
-        ),
-        source: Some(
-            "rustc",
-        ),
-        message: "method `next` has an incompatible type for trait\nexpected type `fn(&mut ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&\'list ty::Ref<M>>`",
-        related_information: None,
-        tags: None,
+            code: Some(
+                String(
+                    "E0053",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "method `next` has an incompatible type for trait\nexpected type `fn(&mut ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<\'list, M>) -> std::option::Option<&\'list ty::Ref<M>>`",
+            related_information: None,
+            tags: None,
+        },
+        fixes: [],
     },
-    fixes: [],
-}
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
index 57df4ceaf..78b7f7cc8 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
@@ -2,45 +2,47 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/runtime/compiler_support.rs",
-        range: Range {
-            start: Position {
-                line: 47,
-                character: 64,
-            },
-            end: Position {
-                line: 47,
-                character: 69,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/runtime/compiler_support.rs",
+            range: Range {
+                start: Position {
+                    line: 47,
+                    character: 64,
+                },
+                end: Position {
+                    line: 47,
+                    character: 69,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 47,
-                character: 64,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 47,
+                    character: 64,
+                },
+                end: Position {
+                    line: 47,
+                    character: 69,
+                },
             },
-            end: Position {
-                line: 47,
-                character: 69,
-            },
-        },
-        severity: Some(
-            Error,
-        ),
-        code: Some(
-            String(
-                "E0308",
+            severity: Some(
+                Error,
             ),
-        ),
-        source: Some(
-            "rustc",
-        ),
-        message: "mismatched types\nexpected usize, found u32",
-        related_information: None,
-        tags: None,
+            code: Some(
+                String(
+                    "E0308",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "mismatched types\nexpected usize, found u32",
+            related_information: None,
+            tags: None,
+        },
+        fixes: [],
     },
-    fixes: [],
-}
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
index 3e1fe736c..5989ed202 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
@@ -2,83 +2,85 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/driver/subcommand/repl.rs",
-        range: Range {
-            start: Position {
-                line: 290,
-                character: 8,
-            },
-            end: Position {
-                line: 290,
-                character: 11,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/driver/subcommand/repl.rs",
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 290,
-                character: 8,
-            },
-            end: Position {
-                line: 290,
-                character: 11,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
             },
-        },
-        severity: Some(
-            Warning,
-        ),
-        code: Some(
-            String(
-                "unused_variables",
+            severity: Some(
+                Warning,
             ),
-        ),
-        source: Some(
-            "rustc",
-        ),
-        message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
-        related_information: None,
-        tags: Some(
-            [
-                Unnecessary,
-            ],
-        ),
-    },
-    fixes: [
-        CodeAction {
-            title: "consider prefixing with an underscore: \'_foo\'",
-            kind: Some(
-                "quickfix",
+            code: Some(
+                String(
+                    "unused_variables",
+                ),
             ),
-            diagnostics: None,
-            edit: Some(
-                WorkspaceEdit {
-                    changes: Some(
-                        {
-                            "file:///test/driver/subcommand/repl.rs": [
-                                TextEdit {
-                                    range: Range {
-                                        start: Position {
-                                            line: 290,
-                                            character: 8,
-                                        },
-                                        end: Position {
-                                            line: 290,
-                                            character: 11,
-                                        },
-                                    },
-                                    new_text: "_foo",
-                                },
-                            ],
-                        },
-                    ),
-                    document_changes: None,
-                },
+            source: Some(
+                "rustc",
+            ),
+            message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+            related_information: None,
+            tags: Some(
+                [
+                    Unnecessary,
+                ],
             ),
-            command: None,
-            is_preferred: None,
         },
-    ],
-}
+        fixes: [
+            CodeAction {
+                title: "consider prefixing with an underscore",
+                kind: Some(
+                    "quickfix",
+                ),
+                diagnostics: None,
+                edit: Some(
+                    WorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/driver/subcommand/repl.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 290,
+                                                character: 8,
+                                            },
+                                            end: Position {
+                                                line: 290,
+                                                character: 11,
+                                            },
+                                        },
+                                        new_text: "_foo",
+                                    },
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+                command: None,
+                is_preferred: None,
+            },
+        ],
+    },
+]
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
index 69301078d..e34b546dc 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
@@ -2,64 +2,66 @@
 source: crates/ra_cargo_watch/src/conv/test.rs
 expression: diag
 ---
-MappedRustDiagnostic {
-    location: Location {
-        uri: "file:///test/compiler/ty/select.rs",
-        range: Range {
-            start: Position {
-                line: 103,
-                character: 17,
-            },
-            end: Position {
-                line: 103,
-                character: 29,
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/compiler/ty/select.rs",
+            range: Range {
+                start: Position {
+                    line: 103,
+                    character: 17,
+                },
+                end: Position {
+                    line: 103,
+                    character: 29,
+                },
             },
         },
-    },
-    diagnostic: Diagnostic {
-        range: Range {
-            start: Position {
-                line: 103,
-                character: 17,
-            },
-            end: Position {
-                line: 103,
-                character: 29,
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 103,
+                    character: 17,
+                },
+                end: Position {
+                    line: 103,
+                    character: 29,
+                },
             },
-        },
-        severity: Some(
-            Error,
-        ),
-        code: Some(
-            String(
-                "E0061",
+            severity: Some(
+                Error,
             ),
-        ),
-        source: Some(
-            "rustc",
-        ),
-        message: "this function takes 2 parameters but 3 parameters were supplied\nexpected 2 parameters",
-        related_information: Some(
-            [
-                DiagnosticRelatedInformation {
-                    location: Location {
-                        uri: "file:///test/compiler/ty/select.rs",
-                        range: Range {
-                            start: Position {
-                                line: 218,
-                                character: 4,
-                            },
-                            end: Position {
-                                line: 230,
-                                character: 5,
+            code: Some(
+                String(
+                    "E0061",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "this function takes 2 parameters but 3 parameters were supplied\nexpected 2 parameters",
+            related_information: Some(
+                [
+                    DiagnosticRelatedInformation {
+                        location: Location {
+                            uri: "file:///test/compiler/ty/select.rs",
+                            range: Range {
+                                start: Position {
+                                    line: 218,
+                                    character: 4,
+                                },
+                                end: Position {
+                                    line: 230,
+                                    character: 5,
+                                },
                             },
                         },
+                        message: "defined here",
                     },
-                    message: "defined here",
-                },
-            ],
-        ),
-        tags: None,
+                ],
+            ),
+            tags: None,
+        },
+        fixes: [],
     },
-    fixes: [],
-}
+]
diff --git a/crates/ra_cargo_watch/src/conv/test.rs b/crates/ra_cargo_watch/src/conv/test.rs
index 6b86525b8..4e81455ca 100644
--- a/crates/ra_cargo_watch/src/conv/test.rs
+++ b/crates/ra_cargo_watch/src/conv/test.rs
@@ -58,7 +58,7 @@ fn snap_rustc_incompatible_type_for_trait() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
 
@@ -141,7 +141,7 @@ fn snap_rustc_unused_variable() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
 
@@ -266,7 +266,7 @@ fn snap_rustc_wrong_number_of_parameters() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
 
@@ -387,7 +387,7 @@ fn snap_clippy_pass_by_ref() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
 
@@ -431,7 +431,7 @@ fn snap_rustc_mismatched_type() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
 
@@ -703,7 +703,7 @@ fn snap_handles_macro_location() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
 
@@ -933,6 +933,140 @@ fn snap_macro_compiler_error() {
     );
 
     let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root).expect("couldn't map diagnostic");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
+    insta::assert_debug_snapshot!(diag);
+}
+
+#[test]
+#[cfg(not(windows))]
+fn snap_multi_line_fix() {
+    let diag = parse_diagnostic(
+        r##"{
+            "rendered": "warning: returning the result of a let binding from a block\n --> src/main.rs:4:5\n  |\n3 |     let a = (0..10).collect();\n  |     -------------------------- unnecessary let binding\n4 |     a\n  |     ^\n  |\n  = note: `#[warn(clippy::let_and_return)]` on by default\n  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return\nhelp: return the expression directly\n  |\n3 |     \n4 |     (0..10).collect()\n  |\n\n",
+            "children": [
+                {
+                "children": [],
+                "code": null,
+                "level": "note",
+                "message": "`#[warn(clippy::let_and_return)]` on by default",
+                "rendered": null,
+                "spans": []
+                },
+                {
+                "children": [],
+                "code": null,
+                "level": "help",
+                "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return",
+                "rendered": null,
+                "spans": []
+                },
+                {
+                "children": [],
+                "code": null,
+                "level": "help",
+                "message": "return the expression directly",
+                "rendered": null,
+                "spans": [
+                    {
+                    "byte_end": 55,
+                    "byte_start": 29,
+                    "column_end": 31,
+                    "column_start": 5,
+                    "expansion": null,
+                    "file_name": "src/main.rs",
+                    "is_primary": true,
+                    "label": null,
+                    "line_end": 3,
+                    "line_start": 3,
+                    "suggested_replacement": "",
+                    "suggestion_applicability": "MachineApplicable",
+                    "text": [
+                        {
+                        "highlight_end": 31,
+                        "highlight_start": 5,
+                        "text": "    let a = (0..10).collect();"
+                        }
+                    ]
+                    },
+                    {
+                    "byte_end": 61,
+                    "byte_start": 60,
+                    "column_end": 6,
+                    "column_start": 5,
+                    "expansion": null,
+                    "file_name": "src/main.rs",
+                    "is_primary": true,
+                    "label": null,
+                    "line_end": 4,
+                    "line_start": 4,
+                    "suggested_replacement": "(0..10).collect()",
+                    "suggestion_applicability": "MachineApplicable",
+                    "text": [
+                        {
+                        "highlight_end": 6,
+                        "highlight_start": 5,
+                        "text": "    a"
+                        }
+                    ]
+                    }
+                ]
+                }
+            ],
+            "code": {
+                "code": "clippy::let_and_return",
+                "explanation": null
+            },
+            "level": "warning",
+            "message": "returning the result of a let binding from a block",
+            "spans": [
+                {
+                "byte_end": 55,
+                "byte_start": 29,
+                "column_end": 31,
+                "column_start": 5,
+                "expansion": null,
+                "file_name": "src/main.rs",
+                "is_primary": false,
+                "label": "unnecessary let binding",
+                "line_end": 3,
+                "line_start": 3,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "text": [
+                    {
+                    "highlight_end": 31,
+                    "highlight_start": 5,
+                    "text": "    let a = (0..10).collect();"
+                    }
+                ]
+                },
+                {
+                "byte_end": 61,
+                "byte_start": 60,
+                "column_end": 6,
+                "column_start": 5,
+                "expansion": null,
+                "file_name": "src/main.rs",
+                "is_primary": true,
+                "label": null,
+                "line_end": 4,
+                "line_start": 4,
+                "suggested_replacement": null,
+                "suggestion_applicability": null,
+                "text": [
+                    {
+                    "highlight_end": 6,
+                    "highlight_start": 5,
+                    "text": "    a"
+                    }
+                ]
+                }
+            ]
+        }
+        "##,
+    );
+
+    let workspace_root = PathBuf::from("/test/");
+    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
     insta::assert_debug_snapshot!(diag);
 }
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
index f07c34549..94b9c03d0 100644
--- a/crates/ra_cargo_watch/src/lib.rs
+++ b/crates/ra_cargo_watch/src/lib.rs
@@ -197,23 +197,23 @@ impl CheckWatcherThread {
             }
 
             CheckEvent::Msg(Message::CompilerMessage(msg)) => {
-                let map_result =
-                    match map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root) {
-                        Some(map_result) => map_result,
-                        None => return,
-                    };
-
-                let MappedRustDiagnostic { location, diagnostic, fixes } = map_result;
-                let fixes = fixes
-                    .into_iter()
-                    .map(|fix| {
-                        CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
-                    })
-                    .collect();
+                let map_result = map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root);
+                if map_result.is_empty() {
+                    return;
+                }
 
-                task_send
-                    .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
-                    .unwrap();
+                for MappedRustDiagnostic { location, diagnostic, fixes } in map_result {
+                    let fixes = fixes
+                        .into_iter()
+                        .map(|fix| {
+                            CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
+                        })
+                        .collect();
+
+                    task_send
+                        .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
+                        .unwrap();
+                }
             }
 
             CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 947d6ad56..3dc86ca2d 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
 use rustc_hash::FxHashMap;
-use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
+use test_utils::{extract_offset, parse_fixture, parse_single_fixture, CURSOR_MARKER};
 
 use crate::{
     input::CrateName, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf,
@@ -45,23 +45,45 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
 
 impl<DB: SourceDatabaseExt + Default + 'static> WithFixture for DB {}
 
-fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
+fn with_single_file(db: &mut dyn SourceDatabaseExt, ra_fixture: &str) -> FileId {
     let file_id = FileId(0);
     let rel_path: RelativePathBuf = "/main.rs".into();
 
     let mut source_root = SourceRoot::new_local();
     source_root.insert_file(rel_path.clone(), file_id);
 
-    let mut crate_graph = CrateGraph::default();
-    crate_graph.add_crate_root(
-        file_id,
-        Edition::Edition2018,
-        None,
-        CfgOptions::default(),
-        Env::default(),
-    );
-
-    db.set_file_text(file_id, Arc::new(text.to_string()));
+    let fixture = parse_single_fixture(ra_fixture);
+
+    let crate_graph = if let Some(entry) = fixture {
+        let meta = match parse_meta(&entry.meta) {
+            ParsedMeta::File(it) => it,
+            _ => panic!("with_single_file only support file meta"),
+        };
+
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(
+            file_id,
+            meta.edition,
+            meta.krate,
+            meta.cfg,
+            meta.env,
+            Default::default(),
+        );
+        crate_graph
+    } else {
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(
+            file_id,
+            Edition::Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
+        crate_graph
+    };
+
+    db.set_file_text(file_id, Arc::new(ra_fixture.to_string()));
     db.set_file_relative_path(file_id, rel_path);
     db.set_file_source_root(file_id, WORKSPACE);
     db.set_source_root(WORKSPACE, Arc::new(source_root));
@@ -104,7 +126,8 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
                 meta.edition,
                 Some(krate.clone()),
                 meta.cfg,
-                Env::default(),
+                meta.env,
+                Default::default(),
             );
             let prev = crates.insert(krate.clone(), crate_id);
             assert!(prev.is_none());
@@ -141,6 +164,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
     } else {
         for (from, to) in crate_deps {
@@ -167,9 +191,10 @@ struct FileMeta {
     deps: Vec<String>,
     cfg: CfgOptions,
     edition: Edition,
+    env: Env,
 }
 
-//- /lib.rs crate:foo deps:bar,baz
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo)
 fn parse_meta(meta: &str) -> ParsedMeta {
     let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
 
@@ -186,6 +211,7 @@ fn parse_meta(meta: &str) -> ParsedMeta {
     let mut deps = Vec::new();
     let mut edition = Edition::Edition2018;
     let mut cfg = CfgOptions::default();
+    let mut env = Env::default();
     for component in components[1..].iter() {
         let (key, value) = split1(component, ':').unwrap();
         match key {
@@ -200,11 +226,18 @@ fn parse_meta(meta: &str) -> ParsedMeta {
                     }
                 }
             }
+            "env" => {
+                for key in value.split(',') {
+                    if let Some((k, v)) = split1(key, '=') {
+                        env.set(k.into(), v.into());
+                    }
+                }
+            }
             _ => panic!("bad component: {:?}", component),
         }
     }
 
-    ParsedMeta::File(FileMeta { path, krate, deps, edition, cfg })
+    ParsedMeta::File(FileMeta { path, krate, deps, edition, cfg, env })
 }
 
 fn split1(haystack: &str, delim: char) -> Option<(&str, &str)> {
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index b77640b2b..06d40db96 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -113,6 +113,7 @@ pub struct CrateData {
     pub display_name: Option<String>,
     pub cfg_options: CfgOptions,
     pub env: Env,
+    pub extern_source: ExternSource,
     pub dependencies: Vec<Dependency>,
 }
 
@@ -122,11 +123,22 @@ pub enum Edition {
     Edition2015,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ExternSourceId(pub u32);
+
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct Env {
     entries: FxHashMap<String, String>,
 }
 
+// FIXME: Redesign vfs for solve the following limitation ?
+// Note: Some env variables (e.g. OUT_DIR) are located outside of the
+// crate. We store a map to allow remap it to ExternSourceId
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct ExternSource {
+    extern_paths: FxHashMap<String, ExternSourceId>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Dependency {
     pub crate_id: CrateId,
@@ -141,6 +153,7 @@ impl CrateGraph {
         display_name: Option<String>,
         cfg_options: CfgOptions,
         env: Env,
+        extern_source: ExternSource,
     ) -> CrateId {
         let data = CrateData {
             root_file_id: file_id,
@@ -148,6 +161,7 @@ impl CrateGraph {
             display_name,
             cfg_options,
             env,
+            extern_source,
             dependencies: Vec::new(),
         };
         let crate_id = CrateId(self.arena.len() as u32);
@@ -261,6 +275,37 @@ impl fmt::Display for Edition {
     }
 }
 
+impl Env {
+    pub fn set(&mut self, env: &str, value: String) {
+        self.entries.insert(env.to_owned(), value);
+    }
+
+    pub fn get(&self, env: &str) -> Option<String> {
+        self.entries.get(env).cloned()
+    }
+}
+
+impl ExternSource {
+    pub fn extern_path(&self, path: &str) -> Option<(ExternSourceId, RelativePathBuf)> {
+        self.extern_paths.iter().find_map(|(root_path, id)| {
+            if path.starts_with(root_path) {
+                let mut rel_path = &path[root_path.len()..];
+                if rel_path.starts_with("/") {
+                    rel_path = &rel_path[1..];
+                }
+                let rel_path = RelativePathBuf::from_path(rel_path).ok()?;
+                Some((id.clone(), rel_path))
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn set_extern_path(&mut self, root_path: &str, root: ExternSourceId) {
+        self.extern_paths.insert(root_path.to_owned(), root);
+    }
+}
+
 #[derive(Debug)]
 pub struct ParseEditionError {
     invalid_input: String,
@@ -290,6 +335,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         let crate2 = graph.add_crate_root(
             FileId(2u32),
@@ -297,6 +343,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         let crate3 = graph.add_crate_root(
             FileId(3u32),
@@ -304,6 +351,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
         assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
@@ -319,6 +367,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         let crate2 = graph.add_crate_root(
             FileId(2u32),
@@ -326,6 +375,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         let crate3 = graph.add_crate_root(
             FileId(3u32),
@@ -333,6 +383,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
         assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
@@ -347,6 +398,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         let crate2 = graph.add_crate_root(
             FileId(2u32),
@@ -354,6 +406,7 @@ mod tests {
             None,
             CfgOptions::default(),
             Env::default(),
+            Default::default(),
         );
         assert!(graph
             .add_dep(crate1, CrateName::normalize_dashes("crate-name-with-dashes"), crate2)
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index fb002d717..d500d5e85 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -11,7 +11,8 @@ use ra_syntax::{ast, Parse, SourceFile, TextRange, TextUnit};
 pub use crate::{
     cancellation::Canceled,
     input::{
-        CrateGraph, CrateId, CrateName, Dependency, Edition, Env, FileId, SourceRoot, SourceRootId,
+        CrateGraph, CrateId, CrateName, Dependency, Edition, Env, ExternSource, ExternSourceId,
+        FileId, SourceRoot, SourceRootId,
     },
 };
 pub use relative_path::{RelativePath, RelativePathBuf};
@@ -87,6 +88,12 @@ pub trait FileLoader {
     fn resolve_relative_path(&self, anchor: FileId, relative_path: &RelativePath)
         -> Option<FileId>;
     fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>>;
+
+    fn resolve_extern_path(
+        &self,
+        extern_id: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId>;
 }
 
 /// Database which stores all significant input facts: source code and project
@@ -164,4 +171,13 @@ impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
         let source_root = self.0.file_source_root(file_id);
         self.0.source_root_crates(source_root)
     }
+
+    fn resolve_extern_path(
+        &self,
+        extern_id: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        let source_root = self.0.source_root(SourceRootId(extern_id.0));
+        source_root.file_by_relative_path(&relative_path)
+    }
 }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 266c4cff3..42193b492 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -11,6 +11,7 @@ doctest = false
 log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.5.3"
+arrayvec = "0.5.1"
 
 itertools = "0.8.2"
 
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 41d4e2ed3..ff041150b 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
 use std::sync::Arc;
 
+use arrayvec::ArrayVec;
 use either::Either;
 use hir_def::{
     adt::StructKind,
@@ -226,7 +227,9 @@ impl Module {
                     Some((name, def))
                 }
             })
-            .map(|(name, def)| (name.clone(), def.into()))
+            .flat_map(|(name, def)| {
+                ScopeDef::all_items(def).into_iter().map(move |item| (name.clone(), item))
+            })
             .collect()
     }
 
@@ -308,7 +311,11 @@ impl StructField {
         self.parent.variant_data(db).fields()[self.id].name.clone()
     }
 
-    pub fn ty(&self, db: &impl HirDatabase) -> Type {
+    /// Returns the type as in the signature of the struct (i.e., with
+    /// placeholder types for type parameters). This is good for showing
+    /// signature help, but not so good to actually get the type of the field
+    /// when you actually have a variable of the struct.
+    pub fn signature_ty(&self, db: &impl HirDatabase) -> Type {
         let var_id = self.parent.into();
         let generic_def_id: GenericDefId = match self.parent {
             VariantDef::Struct(it) => it.id.into(),
@@ -482,6 +489,10 @@ impl Adt {
         let subst = db.generic_defaults(self.into());
         subst.iter().any(|ty| ty == &Ty::Unknown)
     }
+
+    /// Turns this ADT into a type. Any type parameters of the ADT will be
+    /// turned into unknown types, which is good for e.g. finding the most
+    /// general set of completions, but will not look very nice when printed.
     pub fn ty(self, db: &impl HirDatabase) -> Type {
         let id = AdtId::from(self);
         Type::from_def(db, id.module(db).krate, id)
@@ -1028,7 +1039,7 @@ impl Type {
         krate: CrateId,
         def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
     ) -> Type {
-        let substs = Substs::type_params(db, def);
+        let substs = Substs::build_for_def(db, def).fill_with_unknown().build();
         let ty = db.ty(def.into()).subst(&substs);
         Type::new(db, krate, def, ty)
     }
@@ -1288,15 +1299,36 @@ pub enum ScopeDef {
     Unknown,
 }
 
-impl From<PerNs> for ScopeDef {
-    fn from(def: PerNs) -> Self {
-        def.take_types()
-            .or_else(|| def.take_values())
-            .map(|module_def_id| ScopeDef::ModuleDef(module_def_id.into()))
-            .or_else(|| {
-                def.take_macros().map(|macro_def_id| ScopeDef::MacroDef(macro_def_id.into()))
-            })
-            .unwrap_or(ScopeDef::Unknown)
+impl ScopeDef {
+    pub fn all_items(def: PerNs) -> ArrayVec<[Self; 3]> {
+        let mut items = ArrayVec::new();
+
+        match (def.take_types(), def.take_values()) {
+            (Some(m1), None) => items.push(ScopeDef::ModuleDef(m1.into())),
+            (None, Some(m2)) => items.push(ScopeDef::ModuleDef(m2.into())),
+            (Some(m1), Some(m2)) => {
+                // Some items, like unit structs and enum variants, are
+                // returned as both a type and a value. Here we want
+                // to de-duplicate them.
+                if m1 != m2 {
+                    items.push(ScopeDef::ModuleDef(m1.into()));
+                    items.push(ScopeDef::ModuleDef(m2.into()));
+                } else {
+                    items.push(ScopeDef::ModuleDef(m1.into()));
+                }
+            }
+            (None, None) => {}
+        };
+
+        if let Some(macro_def_id) = def.take_macros() {
+            items.push(ScopeDef::MacroDef(macro_def_id.into()));
+        }
+
+        if items.is_empty() {
+            items.push(ScopeDef::Unknown);
+        }
+
+        items
     }
 }
 
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 3782a9984..788bb3eb7 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -344,7 +344,13 @@ impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
 
         resolver.process_all_names(self.db, &mut |name, def| {
             let def = match def {
-                resolver::ScopeDef::PerNs(it) => it.into(),
+                resolver::ScopeDef::PerNs(it) => {
+                    let items = ScopeDef::all_items(it);
+                    for item in items {
+                        f(name.clone(), item);
+                    }
+                    return;
+                }
                 resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
                 resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
                 resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 57ba45b45..2bc405a59 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -47,13 +47,19 @@ impl Expander {
     pub(crate) fn enter_expand<T: ast::AstNode, DB: DefDatabase>(
         &mut self,
         db: &DB,
+        local_scope: Option<&ItemScope>,
         macro_call: ast::MacroCall,
     ) -> Option<(Mark, T)> {
         let macro_call = InFile::new(self.current_file_id, &macro_call);
 
-        if let Some(call_id) =
-            macro_call.as_call_id(db, |path| self.resolve_path_as_macro(db, &path))
-        {
+        if let Some(call_id) = macro_call.as_call_id(db, |path| {
+            if let Some(local_scope) = local_scope {
+                if let Some(def) = path.as_ident().and_then(|n| local_scope.get_legacy_macro(n)) {
+                    return Some(def);
+                }
+            }
+            self.resolve_path_as_macro(db, &path)
+        }) {
             let file_id = call_id.as_file();
             if let Some(node) = db.parse_or_expand(file_id) {
                 if let Some(expr) = T::cast(node) {
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index ec1b0c2e7..54b5591d3 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -3,7 +3,10 @@
 
 use either::Either;
 
-use hir_expand::name::{name, AsName, Name};
+use hir_expand::{
+    name::{name, AsName, Name},
+    MacroDefId, MacroDefKind,
+};
 use ra_arena::Arena;
 use ra_syntax::{
     ast::{
@@ -452,19 +455,30 @@ where
                     None => self.alloc_expr(Expr::Missing, syntax_ptr),
                 }
             }
-            // FIXME expand to statements in statement position
             ast::Expr::MacroCall(e) => {
-                let macro_call = self.expander.to_source(AstPtr::new(&e));
-                match self.expander.enter_expand(self.db, e) {
-                    Some((mark, expansion)) => {
-                        self.source_map
-                            .expansions
-                            .insert(macro_call, self.expander.current_file_id);
-                        let id = self.collect_expr(expansion);
-                        self.expander.exit(self.db, mark);
-                        id
+                if let Some(name) = is_macro_rules(&e) {
+                    let mac = MacroDefId {
+                        krate: Some(self.expander.module.krate),
+                        ast_id: Some(self.expander.ast_id(&e)),
+                        kind: MacroDefKind::Declarative,
+                    };
+                    self.body.item_scope.define_legacy_macro(name, mac);
+
+                    // FIXME: do we still need to allocate this as missing ?
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                } else {
+                    let macro_call = self.expander.to_source(AstPtr::new(&e));
+                    match self.expander.enter_expand(self.db, Some(&self.body.item_scope), e) {
+                        Some((mark, expansion)) => {
+                            self.source_map
+                                .expansions
+                                .insert(macro_call, self.expander.current_file_id);
+                            let id = self.collect_expr(expansion);
+                            self.expander.exit(self.db, mark);
+                            id
+                        }
+                        None => self.alloc_expr(Expr::Missing, syntax_ptr),
                     }
-                    None => self.alloc_expr(Expr::Missing, syntax_ptr),
                 }
             }
 
@@ -686,6 +700,16 @@ where
     }
 }
 
+fn is_macro_rules(m: &ast::MacroCall) -> Option<Name> {
+    let name = m.path()?.segment()?.name_ref()?.as_name();
+
+    if name == name![macro_rules] {
+        Some(m.name()?.as_name())
+    } else {
+        None
+    }
+}
+
 impl From<ast::BinOp> for BinaryOp {
     fn from(ast_op: ast::BinOp) -> Self {
         match ast_op {
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index a72eb5369..c0b16b7fa 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -34,7 +34,8 @@ pub struct FunctionData {
 
 impl FunctionData {
     pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
-        let src = func.lookup(db).source(db);
+        let loc = func.lookup(db);
+        let src = loc.source(db);
         let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
         let mut params = Vec::new();
         let mut has_self_param = false;
@@ -76,7 +77,9 @@ impl FunctionData {
             ret_type
         };
 
-        let visibility = RawVisibility::from_ast(db, src.map(|s| s.visibility()));
+        let vis_default = RawVisibility::default_for_container(loc.container);
+        let visibility =
+            RawVisibility::from_ast_with_default(db, vis_default, src.map(|s| s.visibility()));
 
         let sig = FunctionData { name, params, ret_type, has_self_param, visibility };
         Arc::new(sig)
@@ -105,10 +108,13 @@ impl TypeAliasData {
         db: &impl DefDatabase,
         typ: TypeAliasId,
     ) -> Arc<TypeAliasData> {
-        let node = typ.lookup(db).source(db);
+        let loc = typ.lookup(db);
+        let node = loc.source(db);
         let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
         let type_ref = node.value.type_ref().map(TypeRef::from_ast);
-        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        let vis_default = RawVisibility::default_for_container(loc.container);
+        let visibility =
+            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
         Arc::new(TypeAliasData { name, type_ref, visibility })
     }
 }
@@ -230,22 +236,26 @@ pub struct ConstData {
 
 impl ConstData {
     pub(crate) fn const_data_query(db: &impl DefDatabase, konst: ConstId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(db, node))
+        let loc = konst.lookup(db);
+        let node = loc.source(db);
+        let vis_default = RawVisibility::default_for_container(loc.container);
+        Arc::new(ConstData::new(db, vis_default, node))
     }
 
     pub(crate) fn static_data_query(db: &impl DefDatabase, konst: StaticId) -> Arc<ConstData> {
         let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(db, node))
+        Arc::new(ConstData::new(db, RawVisibility::private(), node))
     }
 
     fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
         db: &impl DefDatabase,
+        vis_default: RawVisibility,
         node: InFile<N>,
     ) -> ConstData {
         let name = node.value.name().map(|n| n.as_name());
         let type_ref = TypeRef::from_ast_opt(node.value.ascribed_type());
-        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        let visibility =
+            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
         ConstData { name, type_ref, visibility }
     }
 }
@@ -280,7 +290,7 @@ fn collect_impl_items_in_macro(
         return Vec::new();
     }
 
-    if let Some((mark, items)) = expander.enter_expand(db, m) {
+    if let Some((mark, items)) = expander.enter_expand(db, None, m) {
         let items: InFile<ast::MacroItems> = expander.to_source(items);
         let mut res = collect_impl_items(
             db,
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index d0459d9b0..db9838cb5 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -102,6 +102,7 @@ struct MacroDirective {
     module_id: LocalModuleId,
     ast_id: AstIdWithPath<ast::MacroCall>,
     legacy: Option<MacroCallId>,
+    depth: usize,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -134,6 +135,7 @@ where
         self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
         ModCollector {
             def_collector: &mut *self,
+            macro_depth: 0,
             module_id,
             file_id: file_id.into(),
             raw_items: &raw_items,
@@ -516,7 +518,7 @@ where
         macros.retain(|directive| {
             if let Some(call_id) = directive.legacy {
                 res = ReachedFixedPoint::No;
-                resolved.push((directive.module_id, call_id));
+                resolved.push((directive.module_id, call_id, directive.depth));
                 return false;
             }
 
@@ -530,7 +532,7 @@ where
                 );
                 resolved_res.resolved_def.take_macros()
             }) {
-                resolved.push((directive.module_id, call_id));
+                resolved.push((directive.module_id, call_id, directive.depth));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -541,7 +543,7 @@ where
             if let Some(call_id) =
                 directive.ast_id.as_call_id(self.db, |path| self.resolve_attribute_macro(&path))
             {
-                resolved.push((directive.module_id, call_id));
+                resolved.push((directive.module_id, call_id, 0));
                 res = ReachedFixedPoint::No;
                 return false;
             }
@@ -552,8 +554,12 @@ where
         self.unexpanded_macros = macros;
         self.unexpanded_attribute_macros = attribute_macros;
 
-        for (module_id, macro_call_id) in resolved {
-            self.collect_macro_expansion(module_id, macro_call_id);
+        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);
         }
 
         res
@@ -573,12 +579,18 @@ where
         None
     }
 
-    fn collect_macro_expansion(&mut self, module_id: LocalModuleId, macro_call_id: MacroCallId) {
+    fn collect_macro_expansion(
+        &mut self,
+        module_id: LocalModuleId,
+        macro_call_id: MacroCallId,
+        depth: usize,
+    ) {
         let file_id: HirFileId = macro_call_id.as_file();
         let raw_items = self.db.raw_items(file_id);
         let mod_dir = self.mod_dirs[&module_id].clone();
         ModCollector {
             def_collector: &mut *self,
+            macro_depth: depth,
             file_id,
             module_id,
             raw_items: &raw_items,
@@ -595,6 +607,7 @@ where
 /// Walks a single module, populating defs, imports and macros
 struct ModCollector<'a, D> {
     def_collector: D,
+    macro_depth: usize,
     module_id: LocalModuleId,
     file_id: HirFileId,
     raw_items: &'a raw::RawItems,
@@ -684,6 +697,7 @@ where
 
                 ModCollector {
                     def_collector: &mut *self.def_collector,
+                    macro_depth: self.macro_depth,
                     module_id,
                     file_id: self.file_id,
                     raw_items: self.raw_items,
@@ -713,6 +727,7 @@ where
                         let raw_items = self.def_collector.db.raw_items(file_id.into());
                         ModCollector {
                             def_collector: &mut *self.def_collector,
+                            macro_depth: self.macro_depth,
                             module_id,
                             file_id: file_id.into(),
                             raw_items: &raw_items,
@@ -887,6 +902,7 @@ where
                 module_id: self.module_id,
                 ast_id,
                 legacy: Some(macro_call_id),
+                depth: self.macro_depth + 1,
             });
 
             return;
@@ -902,6 +918,7 @@ where
             module_id: self.module_id,
             ast_id,
             legacy: None,
+            depth: self.macro_depth + 1,
         });
     }
 
@@ -971,13 +988,26 @@ mod tests {
     }
 
     #[test]
-    fn test_macro_expand_will_stop() {
+    fn test_macro_expand_will_stop_1() {
+        do_resolve(
+            r#"
+        macro_rules! foo {
+            ($($ty:ty)*) => { foo!($($ty)*); }
+        }
+        foo!(KABOOM);
+        "#,
+        );
+    }
+
+    #[ignore] // this test does succeed, but takes quite a while :/
+    #[test]
+    fn test_macro_expand_will_stop_2() {
         do_resolve(
             r#"
         macro_rules! foo {
-            ($($ty:ty)*) => { foo!($($ty)*, $($ty)*); }
+            ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
         }
-foo!(KABOOM);
+        foo!(KABOOM);
         "#,
         );
     }
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index dda5ed699..3f33a75b9 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -102,6 +102,28 @@ fn crate_def_map_super_super() {
 }
 
 #[test]
+fn crate_def_map_fn_mod_same_name() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod m {
+            pub mod z {}
+            pub fn z() {}
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮m: t
+        ⋮
+        ⋮crate::m
+        ⋮z: t v
+        ⋮
+        ⋮crate::m::z
+    "###)
+}
+
+#[test]
 fn bogus_paths() {
     covers!(bogus_paths);
     let map = def_map(
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 2734d51a0..123fae72a 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -381,6 +381,11 @@ impl Resolver {
         db: &impl DefDatabase,
         path: &ModPath,
     ) -> Option<MacroDefId> {
+        // Search item scope legacy macro first
+        if let Some(def) = self.resolve_local_macro_def(path) {
+            return Some(def);
+        }
+
         let (item_map, module) = self.module_scope()?;
         item_map.resolve_path(db, module, &path, BuiltinShadowMode::Other).0.take_macros()
     }
@@ -413,6 +418,16 @@ impl Resolver {
         })
     }
 
+    fn resolve_local_macro_def(&self, path: &ModPath) -> Option<MacroDefId> {
+        let name = path.as_ident()?;
+        self.scopes.iter().rev().find_map(|scope| {
+            if let Scope::LocalItemsScope(body) = scope {
+                return body.item_scope.get_legacy_macro(name);
+            }
+            None
+        })
+    }
+
     pub fn module(&self) -> Option<ModuleId> {
         let (def_map, local_id) = self.module_scope()?;
         Some(ModuleId { krate: def_map.krate, local_id })
diff --git a/crates/ra_hir_def/src/test_db.rs b/crates/ra_hir_def/src/test_db.rs
index 1568820e9..0756916a8 100644
--- a/crates/ra_hir_def/src/test_db.rs
+++ b/crates/ra_hir_def/src/test_db.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use crate::db::DefDatabase;
-use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
+use ra_db::{salsa, CrateId, ExternSourceId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
 
 #[salsa::database(
     ra_db::SourceDatabaseExtStorage,
@@ -52,6 +52,14 @@ impl FileLoader for TestDB {
     fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
+
+    fn resolve_extern_path(
+        &self,
+        extern_id: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_extern_path(extern_id, relative_path)
+    }
 }
 
 impl TestDB {
diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs
index d8296da4b..e0c59e905 100644
--- a/crates/ra_hir_def/src/visibility.rs
+++ b/crates/ra_hir_def/src/visibility.rs
@@ -6,7 +6,7 @@ use ra_syntax::ast;
 use crate::{
     db::DefDatabase,
     path::{ModPath, PathKind},
-    ModuleId,
+    AssocContainerId, ModuleId,
 };
 
 /// Visibility of an item, not yet resolved.
@@ -20,11 +20,30 @@ pub enum RawVisibility {
 }
 
 impl RawVisibility {
-    const fn private() -> RawVisibility {
+    pub(crate) const fn private() -> RawVisibility {
         let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() };
         RawVisibility::Module(path)
     }
 
+    pub(crate) fn default_for_container(container_id: AssocContainerId) -> Self {
+        match container_id {
+            AssocContainerId::TraitId(_) => RawVisibility::Public,
+            _ => RawVisibility::private(),
+        }
+    }
+
+    pub(crate) fn from_ast_with_default(
+        db: &impl DefDatabase,
+        default: RawVisibility,
+        node: InFile<Option<ast::Visibility>>,
+    ) -> RawVisibility {
+        Self::from_ast_with_hygiene_and_default(
+            node.value,
+            default,
+            &Hygiene::new(db, node.file_id),
+        )
+    }
+
     pub(crate) fn from_ast(
         db: &impl DefDatabase,
         node: InFile<Option<ast::Visibility>>,
@@ -36,8 +55,16 @@ impl RawVisibility {
         node: Option<ast::Visibility>,
         hygiene: &Hygiene,
     ) -> RawVisibility {
+        Self::from_ast_with_hygiene_and_default(node, RawVisibility::private(), hygiene)
+    }
+
+    pub(crate) fn from_ast_with_hygiene_and_default(
+        node: Option<ast::Visibility>,
+        default: RawVisibility,
+        hygiene: &Hygiene,
+    ) -> RawVisibility {
         let node = match node {
-            None => return RawVisibility::private(),
+            None => return default,
             Some(node) => node,
         };
         match node.kind() {
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index 3f60b1cca..f9d3787f6 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -88,17 +88,18 @@ register_builtin! {
     (compile_error, CompileError) => compile_error_expand,
     (file, File) => file_expand,
     (line, Line) => line_expand,
+    (assert, Assert) => assert_expand,
     (stringify, Stringify) => stringify_expand,
     (format_args, FormatArgs) => format_args_expand,
-    (env, Env) => env_expand,
-    (option_env, OptionEnv) => option_env_expand,
     // format_args_nl only differs in that it adds a newline in the end,
     // so we use the same stub expansion for now
     (format_args_nl, FormatArgsNl) => format_args_expand,
 
     EAGER:
     (concat, Concat) => concat_expand,
-    (include, Include) => include_expand
+    (include, Include) => include_expand,
+    (env, Env) => env_expand,
+    (option_env, OptionEnv) => option_env_expand
 }
 
 fn line_expand(
@@ -137,42 +138,56 @@ fn stringify_expand(
     Ok(expanded)
 }
 
-fn env_expand(
+fn column_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     _tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
     // dummy implementation for type-checking purposes
-    // we cannot use an empty string here, because for
-    // `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
-    // `include!("foo.rs"), which maybe infinite loop
-    let expanded = quote! { "__RA_UNIMPLEMENTATED__" };
+    let col_num = 0;
+    let expanded = quote! {
+        #col_num
+    };
 
     Ok(expanded)
 }
 
-fn option_env_expand(
+fn assert_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
-    _tt: &tt::Subtree,
+    tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
-    // dummy implementation for type-checking purposes
-    let expanded = quote! { std::option::Option::None::<&str> };
+    // A hacky implementation for goto def and hover
+    // We expand `assert!(cond, arg1, arg2)` to
+    // ```
+    // {(cond, &(arg1), &(arg2));}
+    // ```,
+    // which is wrong but useful.
 
-    Ok(expanded)
-}
+    let mut args = Vec::new();
+    let mut current = Vec::new();
+    for tt in tt.token_trees.iter().cloned() {
+        match tt {
+            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => {
+                args.push(current);
+                current = Vec::new();
+            }
+            _ => {
+                current.push(tt);
+            }
+        }
+    }
+    if !current.is_empty() {
+        args.push(current);
+    }
+
+    let arg_tts = args.into_iter().flat_map(|arg| {
+        quote! { &(##arg), }
+    }.token_trees).collect::<Vec<_>>();
 
-fn column_expand(
-    _db: &dyn AstDatabase,
-    _id: LazyMacroId,
-    _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
-    // dummy implementation for type-checking purposes
-    let col_num = 0;
     let expanded = quote! {
-        #col_num
+        { { (##arg_tts); } }
     };
-
     Ok(expanded)
 }
 
@@ -278,30 +293,37 @@ fn concat_expand(
 
 fn relative_file(db: &dyn AstDatabase, call_id: MacroCallId, path: &str) -> Option<FileId> {
     let call_site = call_id.as_file().original_file(db);
-    let path = RelativePath::new(&path);
 
-    let res = db.resolve_relative_path(call_site, &path)?;
-    // Prevent include itself
-    if res == call_site {
-        return None;
+    // Handle trivial case
+    if let Some(res) = db.resolve_relative_path(call_site, &RelativePath::new(&path)) {
+        // Prevent include itself
+        return if res == call_site { None } else { Some(res) };
     }
-    Some(res)
+
+    // Extern paths ?
+    let krate = db.relevant_crates(call_site).get(0)?.clone();
+    let (extern_source_id, relative_file) =
+        db.crate_graph()[krate].extern_source.extern_path(path)?;
+
+    db.resolve_extern_path(extern_source_id, &relative_file)
 }
 
-fn include_expand(
-    db: &dyn AstDatabase,
-    arg_id: EagerMacroId,
-    tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let path = tt
-        .token_trees
+fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
+    tt.token_trees
         .get(0)
         .and_then(|tt| match tt {
             tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(&it),
             _ => None,
         })
-        .ok_or_else(|| mbe::ExpandError::ConversionError)?;
+        .ok_or_else(|| mbe::ExpandError::ConversionError)
+}
 
+fn include_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let path = parse_string(tt)?;
     let file_id =
         relative_file(db, arg_id.into(), &path).ok_or_else(|| mbe::ExpandError::ConversionError)?;
 
@@ -314,12 +336,58 @@ fn include_expand(
     Ok((res, FragmentKind::Items))
 }
 
+fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
+    let call_id: MacroCallId = arg_id.into();
+    let original_file = call_id.as_file().original_file(db);
+
+    let krate = db.relevant_crates(original_file).get(0)?.clone();
+    db.crate_graph()[krate].env.get(key)
+}
+
+fn env_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let key = parse_string(tt)?;
+
+    // FIXME:
+    // If the environment variable is not defined int rustc, then a compilation error will be emitted.
+    // We might do the same if we fully support all other stuffs.
+    // But for now on, we should return some dummy string for better type infer purpose.
+    // However, we cannot use an empty string here, because for
+    // `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
+    // `include!("foo.rs"), which might go to infinite loop
+    let s = get_env_inner(db, arg_id, &key).unwrap_or("__RA_UNIMPLEMENTATED__".to_string());
+    let expanded = quote! { #s };
+
+    Ok((expanded, FragmentKind::Expr))
+}
+
+fn option_env_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let key = parse_string(tt)?;
+    let expanded = match get_env_inner(db, arg_id, &key) {
+        None => quote! { std::option::Option::None::<&str> },
+        Some(s) => quote! { std::option::Some(#s) },
+    };
+
+    Ok((expanded, FragmentKind::Expr))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{name::AsName, test_db::TestDB, AstNode, MacroCallId, MacroCallKind, MacroCallLoc};
+    use crate::{
+        name::AsName, test_db::TestDB, AstNode, EagerCallLoc, MacroCallId, MacroCallKind,
+        MacroCallLoc,
+    };
     use ra_db::{fixture::WithFixture, SourceDatabase};
     use ra_syntax::ast::NameOwner;
+    use std::sync::Arc;
 
     fn expand_builtin_macro(ra_fixture: &str) -> String {
         let (db, file_id) = TestDB::with_single_file(&ra_fixture);
@@ -330,27 +398,61 @@ mod tests {
         let ast_id_map = db.ast_id_map(file_id.into());
 
         let expander = find_by_name(&macro_calls[0].name().unwrap().as_name()).unwrap();
-        let expander = expander.left().unwrap();
 
-        // the first one should be a macro_rules
-        let def = MacroDefId {
-            krate: Some(CrateId(0)),
-            ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
-            kind: MacroDefKind::BuiltIn(expander),
-        };
+        let file_id = match expander {
+            Either::Left(expander) => {
+                // the first one should be a macro_rules
+                let def = MacroDefId {
+                    krate: Some(CrateId(0)),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                    kind: MacroDefKind::BuiltIn(expander),
+                };
 
-        let loc = MacroCallLoc {
-            def,
-            kind: MacroCallKind::FnLike(AstId::new(
-                file_id.into(),
-                ast_id_map.ast_id(&macro_calls[1]),
-            )),
-        };
+                let loc = MacroCallLoc {
+                    def,
+                    kind: MacroCallKind::FnLike(AstId::new(
+                        file_id.into(),
+                        ast_id_map.ast_id(&macro_calls[1]),
+                    )),
+                };
+
+                let id: MacroCallId = db.intern_macro(loc).into();
+                id.as_file()
+            }
+            Either::Right(expander) => {
+                // the first one should be a macro_rules
+                let def = MacroDefId {
+                    krate: Some(CrateId(0)),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                    kind: MacroDefKind::BuiltInEager(expander),
+                };
 
-        let id: MacroCallId = db.intern_macro(loc).into();
-        let parsed = db.parse_or_expand(id.as_file()).unwrap();
+                let args = macro_calls[1].token_tree().unwrap();
+                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
+
+                let arg_id = db.intern_eager_expansion({
+                    EagerCallLoc {
+                        def,
+                        fragment: FragmentKind::Expr,
+                        subtree: Arc::new(parsed_args.clone()),
+                        file_id: file_id.into(),
+                    }
+                });
+
+                let (subtree, fragment) = expander.expand(&db, arg_id, &parsed_args).unwrap();
+                let eager = EagerCallLoc {
+                    def,
+                    fragment,
+                    subtree: Arc::new(subtree),
+                    file_id: file_id.into(),
+                };
 
-        parsed.text().to_string()
+                let id: MacroCallId = db.intern_eager_expansion(eager.into()).into();
+                id.as_file()
+            }
+        };
+
+        db.parse_or_expand(file_id).unwrap().to_string()
     }
 
     #[test]
@@ -432,6 +534,22 @@ mod tests {
     }
 
     #[test]
+    fn test_assert_expand() {
+        let expanded = expand_builtin_macro(
+            r#"
+            #[rustc_builtin_macro]
+            macro_rules! assert {
+                ($cond:expr) => ({ /* compiler built-in */ });
+                ($cond:expr, $($args:tt)*) => ({ /* compiler built-in */ })
+            }
+            assert!(true, "{} {:?}", arg1(a, b, c), arg2);
+            "#,
+        );
+
+        assert_eq!(expanded, "{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}");
+    }
+
+    #[test]
     fn test_compile_error_expand() {
         let expanded = expand_builtin_macro(
             r#"
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 3fce73e8a..7b72eb7a0 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -17,7 +17,7 @@ pub mod eager;
 use std::hash::Hash;
 use std::sync::Arc;
 
-use ra_db::{salsa, CrateId, FileId};
+use ra_db::{impl_intern_key, salsa, CrateId, FileId};
 use ra_syntax::{
     algo,
     ast::{self, AstNode},
@@ -174,25 +174,11 @@ pub enum MacroCallId {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct LazyMacroId(salsa::InternId);
-impl salsa::InternKey for LazyMacroId {
-    fn from_intern_id(v: salsa::InternId) -> Self {
-        LazyMacroId(v)
-    }
-    fn as_intern_id(&self) -> salsa::InternId {
-        self.0
-    }
-}
+impl_intern_key!(LazyMacroId);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EagerMacroId(salsa::InternId);
-impl salsa::InternKey for EagerMacroId {
-    fn from_intern_id(v: salsa::InternId) -> Self {
-        EagerMacroId(v)
-    }
-    fn as_intern_id(&self) -> salsa::InternId {
-        self.0
-    }
-}
+impl_intern_key!(EagerMacroId);
 
 impl From<LazyMacroId> for MacroCallId {
     fn from(it: LazyMacroId) -> Self {
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 6d201256f..25cc1e9fc 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -172,6 +172,7 @@ pub mod known {
         column,
         compile_error,
         line,
+        assert,
         stringify,
         concat,
         include,
diff --git a/crates/ra_hir_expand/src/quote.rs b/crates/ra_hir_expand/src/quote.rs
index 57e7eebf9..3fd4233da 100644
--- a/crates/ra_hir_expand/src/quote.rs
+++ b/crates/ra_hir_expand/src/quote.rs
@@ -99,6 +99,7 @@ macro_rules! __quote {
     ( & ) => {$crate::__quote!(@PUNCT '&')};
     ( , ) => {$crate::__quote!(@PUNCT ',')};
     ( : ) => {$crate::__quote!(@PUNCT ':')};
+    ( ; ) => {$crate::__quote!(@PUNCT ';')};
     ( :: ) => {$crate::__quote!(@PUNCT ':', ':')};
     ( . ) => {$crate::__quote!(@PUNCT '.')};
     ( < ) => {$crate::__quote!(@PUNCT '<')};
diff --git a/crates/ra_hir_expand/src/test_db.rs b/crates/ra_hir_expand/src/test_db.rs
index 918736e2a..c1fb762de 100644
--- a/crates/ra_hir_expand/src/test_db.rs
+++ b/crates/ra_hir_expand/src/test_db.rs
@@ -5,7 +5,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
+use ra_db::{salsa, CrateId, ExternSourceId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
 
 #[salsa::database(
     ra_db::SourceDatabaseExtStorage,
@@ -51,4 +51,11 @@ impl FileLoader for TestDB {
     fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
+    fn resolve_extern_path(
+        &self,
+        anchor: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_extern_path(anchor, relative_path)
+    }
 }
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index b7e8855fb..7f5e1469e 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs