54 files changed, 1756 insertions, 516 deletions
diff --git a/crates/assists/src/ast_transform.rs b/crates/assists/src/ast_transform.rs
index bbcd2d488..835da3bb2 100644
--- a/crates/assists/src/ast_transform.rs
+++ b/crates/assists/src/ast_transform.rs
@@ -18,6 +18,34 @@ pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
    .rewrite_ast(&node)
 }
+/// `AstTransform` helps with applying bulk transformations to syntax nodes.
+///
+/// This is mostly useful for IDE code generation. If you paste some existing
+/// code into a new context (for example, to add method overrides to an `impl`
+/// block), you generally want to appropriately qualify the names, and sometimes
+/// you might want to substitute generic parameters as well:
+///
+/// ```
+/// mod x {
+///   pub struct A;
+///   pub trait T<U> { fn foo(&self, _: U) -> A; }
+/// }
+///
+/// mod y {
+///   use x::T;
+///
+///   impl T<()> for () {
+///      // If we invoke **Add Missing Members** here, we want to copy-paste `foo`.
+///      // But we want a slightly-modified version of it:
+///      fn foo(&self, _: ()) -> x::A {}
+///   }
+/// }
+/// ```
+///
+/// So, a single `AstTransform` describes such function from `SyntaxNode` to
+/// `SyntaxNode`. Note that the API here is a bit too high-order and high-brow.
+/// We'd want to somehow express this concept simpler, but so far nobody got to
+/// simplifying this!
 pub trait AstTransform<'a> {
    fn get_substitution(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode>;
diff --git a/crates/assists/src/handlers/add_missing_impl_members.rs b/crates/assists/src/handlers/add_missing_impl_members.rs
index 83a2ada9a..1ac5fefd6 100644
--- a/crates/assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/assists/src/handlers/add_missing_impl_members.rs
@@ -111,8 +111,6 @@ fn add_missing_impl_members_inner(
 ) -> Option<()> {
    let _p = profile::span("add_missing_impl_members_inner");
    let impl_def = ctx.find_node_at_offset::<ast::Impl>()?;
-    let impl_item_list = impl_def.assoc_item_list()?;
    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
    let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
@@ -148,11 +146,14 @@ fn add_missing_impl_members_inner(
    let target = impl_def.syntax().text_range();
    acc.add(AssistId(assist_id, AssistKind::QuickFix), label, target, |builder| {
+        let impl_item_list = impl_def.assoc_item_list().unwrap_or(make::assoc_item_list());
        let n_existing_items = impl_item_list.assoc_items().count();
        let source_scope = ctx.sema.scope_for_def(trait_);
-        let target_scope = ctx.sema.scope(impl_item_list.syntax());
+        let target_scope = ctx.sema.scope(impl_def.syntax());
        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
-            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def));
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def.clone()));
        let items = missing_items
            .into_iter()
            .map(|it| ast_transform::apply(&*ast_transform, it))
@@ -162,12 +163,14 @@ fn add_missing_impl_members_inner(
                _ => it,
            })
            .map(|it| edit::remove_attrs_and_docs(&it));
        let new_impl_item_list = impl_item_list.append_items(items);
-        let first_new_item = new_impl_item_list.assoc_items().nth(n_existing_items).unwrap();
+        let new_impl_def = impl_def.with_assoc_item_list(new_impl_item_list);
+        let first_new_item =
+            new_impl_def.assoc_item_list().unwrap().assoc_items().nth(n_existing_items).unwrap();
-        let original_range = impl_item_list.syntax().text_range();
        match ctx.config.snippet_cap {
-            None => builder.replace(original_range, new_impl_item_list.to_string()),
+            None => builder.replace(target, new_impl_def.to_string()),
            Some(cap) => {
                let mut cursor = Cursor::Before(first_new_item.syntax());
                let placeholder;
@@ -181,8 +184,8 @@ fn add_missing_impl_members_inner(
                }
                builder.replace_snippet(
                    cap,
-                    original_range,
+                    target,
-                    render_snippet(cap, new_impl_item_list.syntax(), cursor),
+                    render_snippet(cap, new_impl_def.syntax(), cursor),
                )
            }
        };
@@ -311,6 +314,25 @@ impl Foo for S {
    }
    #[test]
+    fn test_impl_def_without_braces() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S<|>"#,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+    #[test]
    fn fill_in_type_params_1() {
        check_assist(
            add_missing_impl_members,
@@ -393,6 +415,41 @@ impl foo::Foo for S {
    }
    #[test]
+    fn test_qualify_path_2() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub mod bar {
+        pub struct Bar;
+        pub trait Foo { fn foo(&self, bar: Bar); }
+    }
+}
+use foo::bar;
+struct S;
+impl bar::Foo for S { <|> }"#,
+            r#"
+mod foo {
+    pub mod bar {
+        pub struct Bar;
+        pub trait Foo { fn foo(&self, bar: Bar); }
+    }
+}
+use foo::bar;
+struct S;
+impl bar::Foo for S {
+    fn foo(&self, bar: bar::Bar) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+    #[test]
    fn test_qualify_path_generic() {
        check_assist(
            add_missing_impl_members,
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index 5a1b5a4ac..fa524ffd9 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -192,10 +192,10 @@ impl AutoImportAssets {
            })
            .filter_map(|candidate| match candidate {
                Either::Left(module_def) => {
-                    self.module_with_name_to_import.find_use_path(db, module_def)
+                    self.module_with_name_to_import.find_use_path_prefixed(db, module_def)
                }
                Either::Right(macro_def) => {
-                    self.module_with_name_to_import.find_use_path(db, macro_def)
+                    self.module_with_name_to_import.find_use_path_prefixed(db, macro_def)
                }
            })
            .filter(|use_path| !use_path.segments.is_empty())
@@ -287,6 +287,35 @@ mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
    #[test]
+    fn applicable_when_found_an_import_partial() {
+        check_assist(
+            auto_import,
+            r"
+            mod std {
+                pub mod fmt {
+                    pub struct Formatter;
+                }
+            }
+            use std::fmt;
+            <|>Formatter
+            ",
+            r"
+            mod std {
+                pub mod fmt {
+                    pub struct Formatter;
+                }
+            }
+            use std::fmt::{self, Formatter};
+            Formatter
+            ",
+        );
+    }
+    #[test]
    fn applicable_when_found_an_import() {
        check_assist(
            auto_import,
diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs
index 294256297..461fcf862 100644
--- a/crates/assists/src/handlers/invert_if.rs
+++ b/crates/assists/src/handlers/invert_if.rs
@@ -49,13 +49,14 @@ pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
        ast::ElseBranch::IfExpr(_) => return None,
    };
-    let cond_range = cond.syntax().text_range();
-    let flip_cond = invert_boolean_expression(cond);
-    let else_node = else_block.syntax();
-    let else_range = else_node.text_range();
-    let then_range = then_node.text_range();
    acc.add(AssistId("invert_if", AssistKind::RefactorRewrite), "Invert if", if_range, |edit| {
-        edit.replace(cond_range, flip_cond.syntax().text());
+        let flip_cond = invert_boolean_expression(cond.clone());
+        edit.replace_ast(cond, flip_cond);
+        let else_node = else_block.syntax();
+        let else_range = else_node.text_range();
+        let then_range = then_node.text_range();
        edit.replace(else_range, then_node.text());
        edit.replace(then_range, else_node.text());
    })
diff --git a/crates/assists/src/handlers/merge_imports.rs b/crates/assists/src/handlers/merge_imports.rs
index 0bd679260..fe33cee53 100644
--- a/crates/assists/src/handlers/merge_imports.rs
+++ b/crates/assists/src/handlers/merge_imports.rs
@@ -95,7 +95,7 @@ use std::fmt::Debug;
 use std::fmt<|>::Display;
 ",
            r"
-use std::fmt::{Display, Debug};
+use std::fmt::{Debug, Display};
 ",
        );
    }
@@ -122,7 +122,7 @@ use std::fmt::{self, Display};
 use std::{fmt, <|>fmt::Display};
 ",
            r"
-use std::{fmt::{Display, self}};
+use std::{fmt::{self, Display}};
 ",
        );
    }
@@ -210,13 +210,17 @@ use std::{fmt<|>::Debug, fmt::Display};
 use std::{fmt::{Debug, Display}};
 ",
        );
+    }
+    #[test]
+    fn test_merge_nested2() {
        check_assist(
            merge_imports,
            r"
 use std::{fmt::Debug, fmt<|>::Display};
 ",
            r"
-use std::{fmt::{Display, Debug}};
+use std::{fmt::{Debug, Display}};
 ",
        );
    }
@@ -310,9 +314,7 @@ use foo::<|>{
 };
 ",
            r"
-use foo::{
+use foo::{FooBar, bar::baz};
-    FooBar,
-bar::baz};
 ",
        )
    }
diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index 27b49455c..74afc123b 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -298,7 +298,7 @@ impl std::fmt<|> for Foo {
 }
    ",
            r"
-use std::fmt::{Debug, self};
+use std::fmt::{self, Debug};
 impl fmt for Foo {
 }
@@ -316,9 +316,8 @@ use std::fmt::{Debug, nested::{Display}};
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            // FIXME(veykril): should be nested::{self, Display} here
            r"
-use std::fmt::{Debug, nested::{Display}, nested};
+use std::fmt::{Debug, nested::{self, Display}};
 impl nested for Foo {
 }
@@ -336,9 +335,8 @@ use std::fmt::{Debug, nested::{self, Display}};
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            // FIXME(veykril): nested is duplicated now
            r"
-use std::fmt::{Debug, nested::{self, Display}, nested};
+use std::fmt::{Debug, nested::{self, Display}};
 impl nested for Foo {
 }
@@ -357,7 +355,7 @@ impl std::fmt::nested::Debug<|> for Foo {
 }
 ",
            r"
-use std::fmt::{Debug, nested::{Display}, nested::Debug};
+use std::fmt::{Debug, nested::{Debug, Display}};
 impl Debug for Foo {
 }
@@ -395,7 +393,7 @@ impl std::fmt::Display<|> for Foo {
 }
 ",
            r"
-use std::fmt::{nested::Debug, Display};
+use std::fmt::{Display, nested::Debug};
 impl Display for Foo {
 }
@@ -415,12 +413,8 @@ use crate::{
 fn foo() { crate::ty::lower<|>::trait_env() }
 ",
-            // FIXME(veykril): formatting broke here
            r"
-use crate::{
+use crate::{AssocItem, ty::{Substs, Ty, lower}};
-    ty::{Substs, Ty},
-    AssocItem,
-ty::lower};
 fn foo() { lower::trait_env() }
 ",
@@ -619,7 +613,7 @@ fn main() {
 }
    ",
            r"
-use std::fmt::{Display, self};
+use std::fmt::{self, Display};
 fn main() {
    fmt;
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/assists/src/utils/insert_use.rs
index 6d110aaaf..5719b06af 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/assists/src/utils/insert_use.rs
@@ -1,7 +1,9 @@
 //! Handle syntactic aspects of inserting a new `use`.
-use std::iter::{self, successors};
+use std::{
+    cmp::Ordering,
+    iter::{self, successors},
+};
-use algo::skip_trivia_token;
 use ast::{
    edit::{AstNodeEdit, IndentLevel},
    PathSegmentKind, VisibilityOwner,
@@ -9,9 +11,8 @@ use ast::{
 use syntax::{
    algo,
    ast::{self, make, AstNode},
-    Direction, InsertPosition, SyntaxElement, SyntaxNode, T,
+    InsertPosition, SyntaxElement, SyntaxNode,
 };
-use test_utils::mark;
 #[derive(Debug)]
 pub enum ImportScope {
@@ -119,7 +120,6 @@ pub(crate) fn insert_use(
        }
        if let ident_level @ 1..=usize::MAX = scope.indent_level().0 as usize {
-            // FIXME: this alone doesnt properly re-align all cases
            buf.push(make::tokens::whitespace(&" ".repeat(4 * ident_level)).into());
        }
        buf.push(use_item.syntax().clone().into());
@@ -149,66 +149,123 @@ fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -
 }
 pub(crate) fn try_merge_imports(
-    old: &ast::Use,
+    lhs: &ast::Use,
-    new: &ast::Use,
+    rhs: &ast::Use,
    merge_behaviour: MergeBehaviour,
 ) -> Option<ast::Use> {
    // don't merge imports with different visibilities
-    if !eq_visibility(old.visibility(), new.visibility()) {
+    if !eq_visibility(lhs.visibility(), rhs.visibility()) {
        return None;
    }
-    let old_tree = old.use_tree()?;
+    let lhs_tree = lhs.use_tree()?;
-    let new_tree = new.use_tree()?;
+    let rhs_tree = rhs.use_tree()?;
-    let merged = try_merge_trees(&old_tree, &new_tree, merge_behaviour)?;
+    let merged = try_merge_trees(&lhs_tree, &rhs_tree, merge_behaviour)?;
-    Some(old.with_use_tree(merged))
+    Some(lhs.with_use_tree(merged))
-}
-/// Simple function that checks if a UseTreeList is deeper than one level
-fn use_tree_list_is_nested(tl: &ast::UseTreeList) -> bool {
-    tl.use_trees().any(|use_tree| {
-        use_tree.use_tree_list().is_some() || use_tree.path().and_then(|p| p.qualifier()).is_some()
-    })
 }
-// FIXME: currently this merely prepends the new tree into old, ideally it would insert the items in a sorted fashion
 pub(crate) fn try_merge_trees(
-    old: &ast::UseTree,
+    lhs: &ast::UseTree,
-    new: &ast::UseTree,
+    rhs: &ast::UseTree,
-    merge_behaviour: MergeBehaviour,
+    merge: MergeBehaviour,
 ) -> Option<ast::UseTree> {
-    let lhs_path = old.path()?;
+    let lhs_path = lhs.path()?;
-    let rhs_path = new.path()?;
+    let rhs_path = rhs.path()?;
    let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
-    let lhs = old.split_prefix(&lhs_prefix);
+    let lhs = lhs.split_prefix(&lhs_prefix);
-    let rhs = new.split_prefix(&rhs_prefix);
+    let rhs = rhs.split_prefix(&rhs_prefix);
-    let lhs_tl = lhs.use_tree_list()?;
+    recursive_merge(&lhs, &rhs, merge).map(|(merged, _)| merged)
-    let rhs_tl = rhs.use_tree_list()?;
+}
-    // if we are only allowed to merge the last level check if the split off paths are only one level deep
-    if merge_behaviour == MergeBehaviour::Last
-        && (use_tree_list_is_nested(&lhs_tl) || use_tree_list_is_nested(&rhs_tl))
-    {
-        mark::hit!(test_last_merge_too_long);
-        return None;
-    }
-    let should_insert_comma = lhs_tl
+/// Recursively "zips" together lhs and rhs.
-        .r_curly_token()
+fn recursive_merge(
-        .and_then(|it| skip_trivia_token(it.prev_token()?, Direction::Prev))
+    lhs: &ast::UseTree,
-        .map(|it| it.kind())
+    rhs: &ast::UseTree,
-        != Some(T![,]);
+    merge: MergeBehaviour,
-    let mut to_insert: Vec<SyntaxElement> = Vec::new();
+) -> Option<(ast::UseTree, bool)> {
-    if should_insert_comma {
+    let mut use_trees = lhs
-        to_insert.push(make::token(T![,]).into());
+        .use_tree_list()
-        to_insert.push(make::tokens::single_space().into());
+        .into_iter()
-    }
+        .flat_map(|list| list.use_trees())
-    to_insert.extend(
+        // check if any of the use trees are nested, if they are and the behaviour is `last` we are not allowed to merge this
-        rhs_tl.syntax().children_with_tokens().filter(|it| !matches!(it.kind(), T!['{'] | T!['}'])),
+        // so early exit the iterator by using Option's Intoiterator impl
-    );
+        .map(|tree| match merge == MergeBehaviour::Last && tree.use_tree_list().is_some() {
-    let pos = InsertPosition::Before(lhs_tl.r_curly_token()?.into());
+            true => None,
-    let use_tree_list = lhs_tl.insert_children(pos, to_insert);
+            false => Some(tree),
-    Some(lhs.with_use_tree_list(use_tree_list))
+        })
+        .collect::<Option<Vec<_>>>()?;
+    use_trees.sort_unstable_by(|a, b| path_cmp_opt(a.path(), b.path()));
+    for rhs_t in rhs.use_tree_list().into_iter().flat_map(|list| list.use_trees()) {
+        let rhs_path = rhs_t.path();
+        match use_trees.binary_search_by(|p| path_cmp_opt(p.path(), rhs_path.clone())) {
+            Ok(idx) => {
+                let lhs_t = &mut use_trees[idx];
+                let lhs_path = lhs_t.path()?;
+                let rhs_path = rhs_path?;
+                let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
+                if lhs_prefix == lhs_path && rhs_prefix == rhs_path {
+                    let tree_is_self = |tree: ast::UseTree| {
+                        tree.path().as_ref().map(path_is_self).unwrap_or(false)
+                    };
+                    // check if only one of the two trees has a tree list, and whether that then contains `self` or not.
+                    // If this is the case we can skip this iteration since the path without the list is already included in the other one via `self`
+                    let tree_contains_self = |tree: &ast::UseTree| {
+                        tree.use_tree_list()
+                            .map(|tree_list| tree_list.use_trees().any(tree_is_self))
+                            .unwrap_or(false)
+                    };
+                    match (tree_contains_self(&lhs_t), tree_contains_self(&rhs_t)) {
+                        (true, false) => continue,
+                        (false, true) => {
+                            *lhs_t = rhs_t;
+                            continue;
+                        }
+                        _ => (),
+                    }
+                    // glob imports arent part of the use-tree lists so we need to special handle them here as well
+                    // this special handling is only required for when we merge a module import into a glob import of said module
+                    // see the `merge_self_glob` or `merge_mod_into_glob` tests
+                    if lhs_t.star_token().is_some() || rhs_t.star_token().is_some() {
+                        *lhs_t = make::use_tree(
+                            make::path_unqualified(make::path_segment_self()),
+                            None,
+                            None,
+                            false,
+                        );
+                        use_trees.insert(idx, make::glob_use_tree());
+                        continue;
+                    }
+                }
+                let lhs = lhs_t.split_prefix(&lhs_prefix);
+                let rhs = rhs_t.split_prefix(&rhs_prefix);
+                let this_has_children = use_trees.len() > 0;
+                match recursive_merge(&lhs, &rhs, merge) {
+                    Some((_, has_multiple_children))
+                        if merge == MergeBehaviour::Last
+                            && this_has_children
+                            && has_multiple_children =>
+                    {
+                        return None
+                    }
+                    Some((use_tree, _)) => use_trees[idx] = use_tree,
+                    None => use_trees.insert(idx, rhs_t),
+                }
+            }
+            Err(_)
+                if merge == MergeBehaviour::Last
+                    && use_trees.len() > 0
+                    && rhs_t.use_tree_list().is_some() =>
+            {
+                return None
+            }
+            Err(idx) => {
+                use_trees.insert(idx, rhs_t);
+            }
+        }
+    }
+    let has_multiple_children = use_trees.len() > 1;
+    Some((lhs.with_use_tree_list(make::use_tree_list(use_trees)), has_multiple_children))
 }
 /// Traverses both paths until they differ, returning the common prefix of both.
@@ -219,7 +276,7 @@ fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Pa
    loop {
        match (lhs_curr.segment(), rhs_curr.segment()) {
            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
-            _ => break,
+            _ => break res,
        }
        res = Some((lhs_curr.clone(), rhs_curr.clone()));
@@ -228,11 +285,62 @@ fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Pa
                lhs_curr = lhs;
                rhs_curr = rhs;
            }
-            _ => break,
+            _ => break res,
+        }
+    }
+}
+fn path_is_self(path: &ast::Path) -> bool {
+    path.segment().and_then(|seg| seg.self_token()).is_some() && path.qualifier().is_none()
+}
+#[inline]
+fn first_segment(path: &ast::Path) -> Option<ast::PathSegment> {
+    first_path(path).segment()
+}
+fn first_path(path: &ast::Path) -> ast::Path {
+    successors(Some(path.clone()), ast::Path::qualifier).last().unwrap()
+}
+fn segment_iter(path: &ast::Path) -> impl Iterator<Item = ast::PathSegment> + Clone {
+    // cant make use of SyntaxNode::siblings, because the returned Iterator is not clone
+    successors(first_segment(path), |p| p.parent_path().parent_path().and_then(|p| p.segment()))
+}
+/// Orders paths in the following way:
+/// the sole self token comes first, after that come uppercase identifiers, then lowercase identifiers
+// FIXME: rustfmt sort lowercase idents before uppercase, in general we want to have the same ordering rustfmt has
+// which is `self` and `super` first, then identifier imports with lowercase ones first, then glob imports and at last list imports.
+// Example foo::{self, foo, baz, Baz, Qux, *, {Bar}}
+fn path_cmp(a: &ast::Path, b: &ast::Path) -> Ordering {
+    match (path_is_self(a), path_is_self(b)) {
+        (true, true) => Ordering::Equal,
+        (true, false) => Ordering::Less,
+        (false, true) => Ordering::Greater,
+        (false, false) => {
+            let a = segment_iter(a);
+            let b = segment_iter(b);
+            // cmp_by would be useful for us here but that is currently unstable
+            // cmp doesnt work due the lifetimes on text's return type
+            a.zip(b)
+                .flat_map(|(seg, seg2)| seg.name_ref().zip(seg2.name_ref()))
+                .find_map(|(a, b)| match a.text().cmp(b.text()) {
+                    ord @ Ordering::Greater | ord @ Ordering::Less => Some(ord),
+                    Ordering::Equal => None,
+                })
+                .unwrap_or(Ordering::Equal)
        }
    }
+}
-    res
+fn path_cmp_opt(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
+    match (a, b) {
+        (None, None) => Ordering::Equal,
+        (None, Some(_)) => Ordering::Less,
+        (Some(_), None) => Ordering::Greater,
+        (Some(a), Some(b)) => path_cmp(&a, &b),
+    }
 }
 /// What type of merges are allowed.
@@ -279,19 +387,6 @@ impl ImportGroup {
    }
 }
-fn first_segment(path: &ast::Path) -> Option<ast::PathSegment> {
-    first_path(path).segment()
-}
-fn first_path(path: &ast::Path) -> ast::Path {
-    successors(Some(path.clone()), ast::Path::qualifier).last().unwrap()
-}
-fn segment_iter(path: &ast::Path) -> impl Iterator<Item = ast::PathSegment> + Clone {
-    // cant make use of SyntaxNode::siblings, because the returned Iterator is not clone
-    successors(first_segment(path), |p| p.parent_path().parent_path().and_then(|p| p.segment()))
-}
 #[derive(PartialEq, Eq)]
 enum AddBlankLine {
    Before,
@@ -594,7 +689,7 @@ use std::io;",
        check_full(
            "std::foo::bar::Baz",
            r"use std::foo::bar::Qux;",
-            r"use std::foo::bar::{Qux, Baz};",
+            r"use std::foo::bar::{Baz, Qux};",
        )
    }
@@ -603,7 +698,7 @@ use std::io;",
        check_last(
            "std::foo::bar::Baz",
            r"use std::foo::bar::Qux;",
-            r"use std::foo::bar::{Qux, Baz};",
+            r"use std::foo::bar::{Baz, Qux};",
        )
    }
@@ -612,7 +707,7 @@ use std::io;",
        check_full(
            "std::foo::bar::Baz",
            r"use std::foo::bar::{Qux, Quux};",
-            r"use std::foo::bar::{Qux, Quux, Baz};",
+            r"use std::foo::bar::{Baz, Quux, Qux};",
        )
    }
@@ -621,7 +716,7 @@ use std::io;",
        check_last(
            "std::foo::bar::Baz",
            r"use std::foo::bar::{Qux, Quux};",
-            r"use std::foo::bar::{Qux, Quux, Baz};",
+            r"use std::foo::bar::{Baz, Quux, Qux};",
        )
    }
@@ -630,7 +725,7 @@ use std::io;",
        check_full(
            "std::foo::bar::Baz",
            r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
-            r"use std::foo::bar::{Qux, quux::{Fez, Fizz}, Baz};",
+            r"use std::foo::bar::{Baz, Qux, quux::{Fez, Fizz}};",
        )
    }
@@ -645,6 +740,15 @@ use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
    }
    #[test]
+    fn merge_groups_full_nested_deep() {
+        check_full(
+            "std::foo::bar::quux::Baz",
+            r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
+            r"use std::foo::bar::{Qux, quux::{Baz, Fez, Fizz}};",
+        )
+    }
+    #[test]
    fn merge_groups_skip_pub() {
        check_full(
            "std::io",
@@ -670,34 +774,53 @@ use std::io;",
        check_last(
            "std::fmt::Result",
            r"use std::{fmt, io};",
-            r"use std::{self, fmt::Result};
+            r"use std::fmt::{self, Result};
 use std::io;",
        )
    }
    #[test]
+    fn merge_into_module_import() {
+        check_full(
+            "std::fmt::Result",
+            r"use std::{fmt, io};",
+            r"use std::{fmt::{self, Result}, io};",
+        )
+    }
+    #[test]
    fn merge_groups_self() {
        check_full("std::fmt::Debug", r"use std::fmt;", r"use std::fmt::{self, Debug};")
    }
    #[test]
-    fn merge_self_glob() {
+    fn merge_mod_into_glob() {
        check_full(
            "token::TokenKind",
            r"use token::TokenKind::*;",
-            r"use token::TokenKind::{self::*, self};",
+            r"use token::TokenKind::{*, self};",
+        )
+        // FIXME: have it emit `use token::TokenKind::{self, *}`?
+    }
+    #[test]
+    fn merge_self_glob() {
+        check_full("self", r"use self::*;", r"use self::{*, self};")
+        // FIXME: have it emit `use {self, *}`?
+    }
+    #[test]
+    fn merge_glob_nested() {
+        check_full(
+            "foo::bar::quux::Fez",
+            r"use foo::bar::{Baz, quux::*};",
+            r"use foo::bar::{Baz, quux::{self::*, Fez}};",
        )
    }
    #[test]
    fn merge_last_too_long() {
-        mark::check!(test_last_merge_too_long);
+        check_last("foo::bar", r"use foo::bar::baz::Qux;", r"use foo::bar::{self, baz::Qux};");
-        check_last(
-            "foo::bar",
-            r"use foo::bar::baz::Qux;",
-            r"use foo::bar;
-use foo::bar::baz::Qux;",
-        );
    }
    #[test]
@@ -710,6 +833,42 @@ use foo::bar::baz::Qux;",
        );
    }
+    #[test]
+    fn merge_last_fail() {
+        check_merge_only_fail(
+            r"use foo::bar::{baz::{Qux, Fez}};",
+            r"use foo::bar::{baaz::{Quux, Feez}};",
+            MergeBehaviour::Last,
+        );
+    }
+    #[test]
+    fn merge_last_fail1() {
+        check_merge_only_fail(
+            r"use foo::bar::{baz::{Qux, Fez}};",
+            r"use foo::bar::baaz::{Quux, Feez};",
+            MergeBehaviour::Last,
+        );
+    }
+    #[test]
+    fn merge_last_fail2() {
+        check_merge_only_fail(
+            r"use foo::bar::baz::{Qux, Fez};",
+            r"use foo::bar::{baaz::{Quux, Feez}};",
+            MergeBehaviour::Last,
+        );
+    }
+    #[test]
+    fn merge_last_fail3() {
+        check_merge_only_fail(
+            r"use foo::bar::baz::{Qux, Fez};",
+            r"use foo::bar::baaz::{Quux, Feez};",
+            MergeBehaviour::Last,
+        );
+    }
    fn check(
        path: &str,
        ra_fixture_before: &str,
@@ -742,4 +901,23 @@ use foo::bar::baz::Qux;",
    fn check_none(path: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
        check(path, ra_fixture_before, ra_fixture_after, None)
    }
+    fn check_merge_only_fail(ra_fixture0: &str, ra_fixture1: &str, mb: MergeBehaviour) {
+        let use0 = ast::SourceFile::parse(ra_fixture0)
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(ast::Use::cast)
+            .unwrap();
+        let use1 = ast::SourceFile::parse(ra_fixture1)
+            .tree()
+            .syntax()
+            .descendants()
+            .find_map(ast::Use::cast)
+            .unwrap();
+        let result = try_merge_imports(&use0, &use1, mb);
+        assert_eq!(result.map(|u| u.to_string()), None);
+    }
 }
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 16078d104..d982c5f29 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -59,11 +59,12 @@ pub struct FlycheckHandle {
 impl FlycheckHandle {
    pub fn spawn(
+        id: usize,
        sender: Box<dyn Fn(Message) + Send>,
        config: FlycheckConfig,
        workspace_root: PathBuf,
    ) -> FlycheckHandle {
-        let actor = FlycheckActor::new(sender, config, workspace_root);
+        let actor = FlycheckActor::new(id, sender, config, workspace_root);
        let (sender, receiver) = unbounded::<Restart>();
        let thread = jod_thread::spawn(move || actor.run(receiver));
        FlycheckHandle { sender, thread }
@@ -81,7 +82,11 @@ pub enum Message {
    AddDiagnostic { workspace_root: PathBuf, diagnostic: Diagnostic },
    /// Request check progress notification to client
-    Progress(Progress),
+    Progress {
+        /// Flycheck instance ID
+        id: usize,
+        progress: Progress,
+    },
 }
 #[derive(Debug)]
@@ -95,6 +100,7 @@ pub enum Progress {
 struct Restart;
 struct FlycheckActor {
+    id: usize,
    sender: Box<dyn Fn(Message) + Send>,
    config: FlycheckConfig,
    workspace_root: PathBuf,
@@ -113,11 +119,15 @@ enum Event {
 impl FlycheckActor {
    fn new(
+        id: usize,
        sender: Box<dyn Fn(Message) + Send>,
        config: FlycheckConfig,
        workspace_root: PathBuf,
    ) -> FlycheckActor {
-        FlycheckActor { sender, config, workspace_root, cargo_handle: None }
+        FlycheckActor { id, sender, config, workspace_root, cargo_handle: None }
+    }
+    fn progress(&self, progress: Progress) {
+        self.send(Message::Progress { id: self.id, progress });
    }
    fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
        let check_chan = self.cargo_handle.as_ref().map(|cargo| &cargo.receiver);
@@ -139,7 +149,7 @@ impl FlycheckActor {
                    command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
                    if let Ok(child) = command.spawn().map(JodChild) {
                        self.cargo_handle = Some(CargoHandle::spawn(child));
-                        self.send(Message::Progress(Progress::DidStart));
+                        self.progress(Progress::DidStart);
                    }
                }
                Event::CheckEvent(None) => {
@@ -153,11 +163,11 @@ impl FlycheckActor {
                            self.check_command()
                        )
                    }
-                    self.send(Message::Progress(Progress::DidFinish(res)));
+                    self.progress(Progress::DidFinish(res));
                }
                Event::CheckEvent(Some(message)) => match message {
                    cargo_metadata::Message::CompilerArtifact(msg) => {
-                        self.send(Message::Progress(Progress::DidCheckCrate(msg.target.name)));
+                        self.progress(Progress::DidCheckCrate(msg.target.name));
                    }
                    cargo_metadata::Message::CompilerMessage(msg) => {
@@ -179,7 +189,7 @@ impl FlycheckActor {
    }
    fn cancel_check_process(&mut self) {
        if self.cargo_handle.take().is_some() {
-            self.send(Message::Progress(Progress::DidCancel));
+            self.progress(Progress::DidCancel);
        }
    }
    fn check_command(&self) -> Command {
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 7a9747fc7..567fd91af 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -383,6 +383,16 @@ impl Module {
    pub fn find_use_path(self, db: &dyn DefDatabase, item: impl Into<ItemInNs>) -> Option<ModPath> {
        hir_def::find_path::find_path(db, item.into(), self.into())
    }
+    /// Finds a path that can be used to refer to the given item from within
+    /// this module, if possible. This is used for returning import paths for use-statements.
+    pub fn find_use_path_prefixed(
+        self,
+        db: &dyn DefDatabase,
+        item: impl Into<ItemInNs>,
+    ) -> Option<ModPath> {
+        hir_def::find_path::find_path_prefixed(db, item.into(), self.into())
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -709,11 +719,23 @@ impl Function {
    }
    pub fn params(self, db: &dyn HirDatabase) -> Vec<Param> {
+        let resolver = self.id.resolver(db.upcast());
+        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
+        let environment = TraitEnvironment::lower(db, &resolver);
        db.function_data(self.id)
            .params
            .iter()
            .skip(if self.self_param(db).is_some() { 1 } else { 0 })
-            .map(|_| Param { _ty: () })
+            .map(|type_ref| {
+                let ty = Type {
+                    krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
+                    ty: InEnvironment {
+                        value: Ty::from_hir_ext(&ctx, type_ref).0,
+                        environment: environment.clone(),
+                    },
+                };
+                Param { ty }
+            })
            .collect()
    }
@@ -742,15 +764,21 @@ impl From<Mutability> for Access {
    }
 }
+pub struct Param {
+    ty: Type,
+}
+impl Param {
+    pub fn ty(&self) -> &Type {
+        &self.ty
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SelfParam {
    func: FunctionId,
 }
-pub struct Param {
-    _ty: (),
-}
 impl SelfParam {
    pub fn access(self, db: &dyn HirDatabase) -> Access {
        let func_data = db.function_data(self.func);
@@ -908,12 +936,12 @@ impl MacroDef {
    /// Indicate it is a proc-macro
    pub fn is_proc_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::CustomDerive(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(_))
    }
    /// Indicate it is a derive macro
    pub fn is_derive_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::CustomDerive(_) | MacroDefKind::BuiltInDerive(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(_) | MacroDefKind::BuiltInDerive(_))
    }
 }
@@ -1276,6 +1304,14 @@ impl Type {
        )
    }
+    pub fn remove_ref(&self) -> Option<Type> {
+        if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(_), .. }) = self.ty.value {
+            self.ty.value.substs().map(|substs| self.derived(substs[0].clone()))
+        } else {
+            None
+        }
+    }
    pub fn is_unknown(&self) -> bool {
        matches!(self.ty.value, Ty::Unknown)
    }
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 0516a05b4..c61a430e1 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -697,6 +697,25 @@ fn find_root(node: &SyntaxNode) -> SyntaxNode {
    node.ancestors().last().unwrap()
 }
+/// `SemanticScope` encapsulates the notion of a scope (the set of visible
+/// names) at a particular program point.
+///
+/// It is a bit tricky, as scopes do not really exist inside the compiler.
+/// Rather, the compiler directly computes for each reference the definition it
+/// refers to. It might transiently compute the explicit scope map while doing
+/// so, but, generally, this is not something left after the analysis.
+///
+/// However, we do very much need explicit scopes for IDE purposes --
+/// completion, at its core, lists the contents of the current scope. The notion
+/// of scope is also useful to answer questions like "what would be the meaning
+/// of this piece of code if we inserted it into this position?".
+///
+/// So `SemanticsScope` is constructed from a specific program point (a syntax
+/// node or just a raw offset) and provides access to the set of visible names
+/// on a somewhat best-effort basis.
+///
+/// Note that if you are wondering "what does this specific existing name mean?",
+/// you'd better use the `resolve_` family of methods.
 #[derive(Debug)]
 pub struct SemanticsScope<'a> {
    pub db: &'a dyn HirDatabase,
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index 3e19d9117..001b3c5db 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -28,3 +28,52 @@ impl Diagnostic for UnresolvedModule {
        self
    }
 }
+#[derive(Debug)]
+pub struct UnresolvedExternCrate {
+    pub file: HirFileId,
+    pub item: AstPtr<ast::ExternCrate>,
+}
+impl Diagnostic for UnresolvedExternCrate {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-extern-crate")
+    }
+    fn message(&self) -> String {
+        "unresolved extern crate".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.item.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+#[derive(Debug)]
+pub struct UnresolvedImport {
+    pub file: HirFileId,
+    pub node: AstPtr<ast::UseTree>,
+}
+impl Diagnostic for UnresolvedImport {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unresolved-import")
+    }
+    fn message(&self) -> String {
+        "unresolved import".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+    fn is_experimental(&self) -> bool {
+        // This currently results in false positives in the following cases:
+        // - `cfg_if!`-generated code in libstd (we don't load the sysroot correctly)
+        // - `core::arch` (we don't handle `#[path = "../<path>"]` correctly)
+        // - proc macros and/or proc macro generated code
+        true
+    }
+}
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
index ac2c54ac5..baf374144 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -4,6 +4,7 @@ use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
 use test_utils::mark;
+use crate::nameres::CrateDefMap;
 use crate::{
    db::DefDatabase,
    item_scope::ItemInNs,
@@ -18,7 +19,12 @@ use crate::{
 /// *from where* you're referring to the item, hence the `from` parameter.
 pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
    let _p = profile::span("find_path");
-    find_path_inner(db, item, from, MAX_PATH_LEN)
+    find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Not)
+}
+pub fn find_path_prefixed(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+    let _p = profile::span("find_path_absolute");
+    find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Plain)
 }
 const MAX_PATH_LEN: usize = 15;
@@ -36,11 +42,67 @@ impl ModPath {
    }
 }
+fn check_crate_self_super(
+    def_map: &CrateDefMap,
+    item: ItemInNs,
+    from: ModuleId,
+) -> Option<ModPath> {
+    // - if the item is the crate root, return `crate`
+    if item
+        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+            krate: from.krate,
+            local_id: def_map.root,
+        }))
+    {
+        Some(ModPath::from_segments(PathKind::Crate, Vec::new()))
+    } else if item == ItemInNs::Types(from.into()) {
+        // - if the item is the module we're in, use `self`
+        Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
+    } else {
+        if let Some(parent_id) = def_map.modules[from.local_id].parent {
+            // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
+            if item
+                == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+                    krate: from.krate,
+                    local_id: parent_id,
+                }))
+            {
+                return Some(ModPath::from_segments(PathKind::Super(1), Vec::new()));
+            }
+        }
+        None
+    }
+}
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum Prefixed {
+    Not,
+    BySelf,
+    Plain,
+}
+impl Prefixed {
+    #[inline]
+    fn prefix(self) -> Option<PathKind> {
+        match self {
+            Prefixed::Not => None,
+            Prefixed::BySelf => Some(PathKind::Super(0)),
+            Prefixed::Plain => Some(PathKind::Plain),
+        }
+    }
+    #[inline]
+    fn prefixed(self) -> bool {
+        self != Prefixed::Not
+    }
+}
 fn find_path_inner(
    db: &dyn DefDatabase,
    item: ItemInNs,
    from: ModuleId,
    max_len: usize,
+    prefixed: Prefixed,
 ) -> Option<ModPath> {
    if max_len == 0 {
        return None;
@@ -51,41 +113,22 @@ fn find_path_inner(
    // - if the item is already in scope, return the name under which it is
    let def_map = db.crate_def_map(from.krate);
    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
-    if let Some((name, _)) = from_scope.name_of(item) {
+    let scope_name =
-        return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
+        if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
+    if !prefixed.prefixed() && scope_name.is_some() {
+        return scope_name
+            .map(|scope_name| ModPath::from_segments(PathKind::Plain, vec![scope_name]));
    }
-    // - if the item is the crate root, return `crate`
+    if let modpath @ Some(_) = check_crate_self_super(&def_map, item, from) {
-    if item
+        return modpath;
-        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
-            krate: from.krate,
-            local_id: def_map.root,
-        }))
-    {
-        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
-    }
-    // - if the item is the module we're in, use `self`
-    if item == ItemInNs::Types(from.into()) {
-        return Some(ModPath::from_segments(PathKind::Super(0), Vec::new()));
-    }
-    // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
-    if let Some(parent_id) = def_map.modules[from.local_id].parent {
-        if item
-            == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
-                krate: from.krate,
-                local_id: parent_id,
-            }))
-        {
-            return Some(ModPath::from_segments(PathKind::Super(1), Vec::new()));
-        }
    }
    // - if the item is the crate root of a dependency crate, return the name from the extern prelude
    for (name, def_id) in &def_map.extern_prelude {
        if item == ItemInNs::Types(*def_id) {
-            return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
+            let name = scope_name.unwrap_or_else(|| name.clone());
+            return Some(ModPath::from_segments(PathKind::Plain, vec![name]));
        }
    }
@@ -138,6 +181,7 @@ fn find_path_inner(
                ItemInNs::Types(ModuleDefId::ModuleId(module_id)),
                from,
                best_path_len - 1,
+                prefixed,
            ) {
                path.segments.push(name);
@@ -165,6 +209,7 @@ fn find_path_inner(
                    ItemInNs::Types(ModuleDefId::ModuleId(info.container)),
                    from,
                    best_path_len - 1,
+                    prefixed,
                )?;
                path.segments.push(info.path.segments.last().unwrap().clone());
                Some(path)
@@ -181,7 +226,13 @@ fn find_path_inner(
        }
    }
-    best_path
+    if let Some(prefix) = prefixed.prefix() {
+        best_path.or_else(|| {
+            scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name]))
+        })
+    } else {
+        best_path
+    }
 }
 fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
@@ -304,7 +355,7 @@ mod tests {
    /// `code` needs to contain a cursor marker; checks that `find_path` for the
    /// item the `path` refers to returns that same path when called from the
    /// module the cursor is in.
-    fn check_found_path(ra_fixture: &str, path: &str) {
+    fn check_found_path_(ra_fixture: &str, path: &str, absolute: bool) {
        let (db, pos) = TestDB::with_position(ra_fixture);
        let module = db.module_for_file(pos.file_id);
        let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path));
@@ -324,9 +375,20 @@ mod tests {
            .take_types()
            .unwrap();
-        let found_path = find_path(&db, ItemInNs::Types(resolved), module);
+        let found_path = if absolute { find_path_prefixed } else { find_path }(
+            &db,
+            ItemInNs::Types(resolved),
+            module,
+        );
+        assert_eq!(found_path, Some(mod_path), "absolute {}", absolute);
+    }
+    fn check_found_path(ra_fixture: &str, path: &str) {
+        check_found_path_(ra_fixture, path, false);
+    }
-        assert_eq!(found_path, Some(mod_path));
+    fn check_found_path_abs(ra_fixture: &str, path: &str) {
+        check_found_path_(ra_fixture, path, true);
    }
    #[test]
@@ -337,6 +399,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "S");
+        check_found_path_abs(code, "S");
    }
    #[test]
@@ -347,6 +410,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "E::A");
+        check_found_path_abs(code, "E::A");
    }
    #[test]
@@ -359,6 +423,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "foo::S");
+        check_found_path_abs(code, "foo::S");
    }
    #[test]
@@ -373,6 +438,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "super::S");
+        check_found_path_abs(code, "super::S");
    }
    #[test]
@@ -384,6 +450,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "self");
+        check_found_path_abs(code, "self");
    }
    #[test]
@@ -395,6 +462,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "crate");
+        check_found_path_abs(code, "crate");
    }
    #[test]
@@ -407,6 +475,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "crate::S");
+        check_found_path_abs(code, "crate::S");
    }
    #[test]
@@ -418,6 +487,7 @@ mod tests {
            pub struct S;
        "#;
        check_found_path(code, "std::S");
+        check_found_path_abs(code, "std::S");
    }
    #[test]
@@ -430,14 +500,14 @@ mod tests {
            pub struct S;
        "#;
        check_found_path(code, "std_renamed::S");
+        check_found_path_abs(code, "std_renamed::S");
    }
    #[test]
    fn partially_imported() {
        // Tests that short paths are used even for external items, when parts of the path are
        // already in scope.
-        check_found_path(
+        let code = r#"
-            r#"
            //- /main.rs crate:main deps:syntax
            use syntax::ast;
@@ -449,12 +519,11 @@ mod tests {
                    A, B, C,
                }
            }
-        "#,
+        "#;
-            "ast::ModuleItem",
+        check_found_path(code, "ast::ModuleItem");
-        );
+        check_found_path_abs(code, "syntax::ast::ModuleItem");
-        check_found_path(
+        let code = r#"
-            r#"
            //- /main.rs crate:main deps:syntax
            <|>
@@ -465,9 +534,9 @@ mod tests {
                    A, B, C,
                }
            }
-        "#,
+        "#;
-            "syntax::ast::ModuleItem",
+        check_found_path(code, "syntax::ast::ModuleItem");
-        );
+        check_found_path_abs(code, "syntax::ast::ModuleItem");
    }
    #[test]
@@ -481,6 +550,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "bar::S");
+        check_found_path_abs(code, "bar::S");
    }
    #[test]
@@ -494,6 +564,7 @@ mod tests {
            <|>
        "#;
        check_found_path(code, "bar::U");
+        check_found_path_abs(code, "bar::U");
    }
    #[test]
@@ -507,6 +578,7 @@ mod tests {
            pub struct S;
        "#;
        check_found_path(code, "std::S");
+        check_found_path_abs(code, "std::S");
    }
    #[test]
@@ -520,6 +592,7 @@ mod tests {
            pub use prelude::*;
        "#;
        check_found_path(code, "S");
+        check_found_path_abs(code, "S");
    }
    #[test]
@@ -537,6 +610,8 @@ mod tests {
        "#;
        check_found_path(code, "None");
        check_found_path(code, "Some");
+        check_found_path_abs(code, "None");
+        check_found_path_abs(code, "Some");
    }
    #[test]
@@ -553,6 +628,7 @@ mod tests {
            pub use crate::foo::bar::S;
        "#;
        check_found_path(code, "baz::S");
+        check_found_path_abs(code, "baz::S");
    }
    #[test]
@@ -567,6 +643,7 @@ mod tests {
        "#;
        // crate::S would be shorter, but using private imports seems wrong
        check_found_path(code, "crate::bar::S");
+        check_found_path_abs(code, "crate::bar::S");
    }
    #[test]
@@ -585,6 +662,7 @@ mod tests {
            pub use super::foo;
        "#;
        check_found_path(code, "crate::foo::S");
+        check_found_path_abs(code, "crate::foo::S");
    }
    #[test]
@@ -605,6 +683,7 @@ mod tests {
        }
        "#;
        check_found_path(code, "std::sync::Arc");
+        check_found_path_abs(code, "std::sync::Arc");
    }
    #[test]
@@ -629,6 +708,7 @@ mod tests {
        }
        "#;
        check_found_path(code, "core::fmt::Error");
+        check_found_path_abs(code, "core::fmt::Error");
    }
    #[test]
@@ -652,6 +732,7 @@ mod tests {
        }
        "#;
        check_found_path(code, "alloc::sync::Arc");
+        check_found_path_abs(code, "alloc::sync::Arc");
    }
    #[test]
@@ -669,6 +750,7 @@ mod tests {
        pub struct Arc;
        "#;
        check_found_path(code, "megaalloc::Arc");
+        check_found_path_abs(code, "megaalloc::Arc");
    }
    #[test]
@@ -683,5 +765,7 @@ mod tests {
        "#;
        check_found_path(code, "u8");
        check_found_path(code, "u16");
+        check_found_path_abs(code, "u8");
+        check_found_path_abs(code, "u16");
    }
 }
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index f1e9dfd5b..12c24e1ca 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -5,10 +5,12 @@ use std::collections::hash_map::Entry;
 use base_db::CrateId;
 use hir_expand::name::Name;
+use hir_expand::MacroDefKind;
 use once_cell::sync::Lazy;
 use rustc_hash::{FxHashMap, FxHashSet};
 use test_utils::mark;
+use crate::ModuleId;
 use crate::{
    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
    LocalModuleId, Lookup, MacroDefId, ModuleDefId, TraitId,
@@ -265,6 +267,26 @@ impl ItemScope {
    pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
        self.legacy_macros.clone()
    }
+    /// Marks everything that is not a procedural macro as private to `this_module`.
+    pub(crate) fn censor_non_proc_macros(&mut self, this_module: ModuleId) {
+        self.types
+            .values_mut()
+            .chain(self.values.values_mut())
+            .map(|(_, v)| v)
+            .chain(self.unnamed_trait_imports.values_mut())
+            .for_each(|vis| *vis = Visibility::Module(this_module));
+        for (mac, vis) in self.macros.values_mut() {
+            if let MacroDefKind::ProcMacro(_) = mac.kind {
+                // FIXME: Technically this is insufficient since reexports of proc macros are also
+                // forbidden. Practically nobody does that.
+                continue;
+            }
+            *vis = Visibility::Module(this_module);
+        }
+    }
 }
 impl PerNs {
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 52abb8e7f..0fd91b9d0 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -291,7 +291,6 @@ pub enum AttrOwner {
    Variant(Idx<Variant>),
    Field(Idx<Field>),
-    // FIXME: Store variant and field attrs, and stop reparsing them in `attrs_query`.
 }
 macro_rules! from_attrs {
@@ -483,11 +482,16 @@ pub struct Import {
    /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many
    /// `Import`s can map to the same `use` item.
    pub ast_id: FileAstId<ast::Use>,
+    /// Index of this `Import` when the containing `Use` is visited via `ModPath::expand_use_item`.
+    ///
+    /// This can be used to get the `UseTree` this `Import` corresponds to and allows emitting
+    /// precise diagnostics.
+    pub index: usize,
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ExternCrate {
-    pub path: ModPath,
+    pub name: Name,
    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
    /// Whether this is a `#[macro_use] extern crate ...`.
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index d93377c3b..54814f141 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -483,7 +483,7 @@ impl Ctx {
        ModPath::expand_use_item(
            InFile::new(self.file, use_item.clone()),
            &self.hygiene,
-            |path, _tree, is_glob, alias| {
+            |path, _use_tree, is_glob, alias| {
                imports.push(id(tree.imports.alloc(Import {
                    path,
                    alias,
@@ -491,6 +491,7 @@ impl Ctx {
                    is_glob,
                    is_prelude,
                    ast_id,
+                    index: imports.len(),
                })));
            },
        );
@@ -502,7 +503,7 @@ impl Ctx {
        &mut self,
        extern_crate: &ast::ExternCrate,
    ) -> Option<FileItemTreeId<ExternCrate>> {
-        let path = ModPath::from_name_ref(&extern_crate.name_ref()?);
+        let name = extern_crate.name_ref()?.as_name();
        let alias = extern_crate.rename().map(|a| {
            a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
        });
@@ -511,7 +512,7 @@ impl Ctx {
        // FIXME: cfg_attr
        let is_macro_use = extern_crate.has_atom_attr("macro_use");
-        let res = ExternCrate { path, alias, visibility, is_macro_use, ast_id };
+        let res = ExternCrate { name, alias, visibility, is_macro_use, ast_id };
        Some(id(self.data().extern_crates.alloc(res)))
    }
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
index eed3d0d6f..1a806cda5 100644
--- a/crates/hir_def/src/item_tree/tests.rs
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -228,11 +228,11 @@ fn smoke() {
            top-level items:
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }]
-            Import { path: ModPath { kind: Plain, segments: [Name(Text("a"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: false, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0) }
+            Import { path: ModPath { kind: Plain, segments: [Name(Text("a"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: false, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0), index: 0 }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }]
-            Import { path: ModPath { kind: Plain, segments: [Name(Text("b"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: true, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0) }
+            Import { path: ModPath { kind: Plain, segments: [Name(Text("b"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: true, is_prelude: false, ast_id: FileAstId::<syntax::ast::generated::nodes::Use>(0), index: 1 }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("ext_crate"))] }, input: None }]) }]
-            ExternCrate { path: ModPath { kind: Plain, segments: [Name(Text("krate"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_macro_use: false, ast_id: FileAstId::<syntax::ast::generated::nodes::ExternCrate>(1) }
+            ExternCrate { name: Name(Text("krate")), alias: None, visibility: RawVisibilityId("pub(self)"), is_macro_use: false, ast_id: FileAstId::<syntax::ast::generated::nodes::ExternCrate>(1) }
            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_trait"))] }, input: None }]) }]
            Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [TypeAlias(Idx::<TypeAlias>(0)), Const(Idx::<Const>(0)), Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<syntax::ast::generated::nodes::Trait>(2) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_ty"))] }, input: None }]) }]
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index bf302172d..5e4d73c1f 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -288,31 +288,70 @@ pub enum ModuleSource {
 mod diagnostics {
    use hir_expand::diagnostics::DiagnosticSink;
+    use hir_expand::hygiene::Hygiene;
+    use hir_expand::InFile;
    use syntax::{ast, AstPtr};
-    use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
+    use crate::path::ModPath;
+    use crate::{db::DefDatabase, diagnostics::*, nameres::LocalModuleId, AstId};
    #[derive(Debug, PartialEq, Eq)]
-    pub(super) enum DefDiagnostic {
+    enum DiagnosticKind {
-        UnresolvedModule {
+        UnresolvedModule { declaration: AstId<ast::Module>, candidate: String },
-            module: LocalModuleId,
-            declaration: AstId<ast::Module>,
+        UnresolvedExternCrate { ast: AstId<ast::ExternCrate> },
-            candidate: String,
-        },
+        UnresolvedImport { ast: AstId<ast::Use>, index: usize },
+    }
+    #[derive(Debug, PartialEq, Eq)]
+    pub(super) struct DefDiagnostic {
+        in_module: LocalModuleId,
+        kind: DiagnosticKind,
    }
    impl DefDiagnostic {
+        pub(super) fn unresolved_module(
+            container: LocalModuleId,
+            declaration: AstId<ast::Module>,
+            candidate: String,
+        ) -> Self {
+            Self {
+                in_module: container,
+                kind: DiagnosticKind::UnresolvedModule { declaration, candidate },
+            }
+        }
+        pub(super) fn unresolved_extern_crate(
+            container: LocalModuleId,
+            declaration: AstId<ast::ExternCrate>,
+        ) -> Self {
+            Self {
+                in_module: container,
+                kind: DiagnosticKind::UnresolvedExternCrate { ast: declaration },
+            }
+        }
+        pub(super) fn unresolved_import(
+            container: LocalModuleId,
+            ast: AstId<ast::Use>,
+            index: usize,
+        ) -> Self {
+            Self { in_module: container, kind: DiagnosticKind::UnresolvedImport { ast, index } }
+        }
        pub(super) fn add_to(
            &self,
            db: &dyn DefDatabase,
            target_module: LocalModuleId,
            sink: &mut DiagnosticSink,
        ) {
-            match self {
+            if self.in_module != target_module {
-                DefDiagnostic::UnresolvedModule { module, declaration, candidate } => {
+                return;
-                    if *module != target_module {
+            }
-                        return;
-                    }
+            match &self.kind {
+                DiagnosticKind::UnresolvedModule { declaration, candidate } => {
                    let decl = declaration.to_node(db.upcast());
                    sink.push(UnresolvedModule {
                        file: declaration.file_id,
@@ -320,6 +359,36 @@ mod diagnostics {
                        candidate: candidate.clone(),
                    })
                }
+                DiagnosticKind::UnresolvedExternCrate { ast } => {
+                    let item = ast.to_node(db.upcast());
+                    sink.push(UnresolvedExternCrate {
+                        file: ast.file_id,
+                        item: AstPtr::new(&item),
+                    });
+                }
+                DiagnosticKind::UnresolvedImport { ast, index } => {
+                    let use_item = ast.to_node(db.upcast());
+                    let hygiene = Hygiene::new(db.upcast(), ast.file_id);
+                    let mut cur = 0;
+                    let mut tree = None;
+                    ModPath::expand_use_item(
+                        InFile::new(ast.file_id, use_item),
+                        &hygiene,
+                        |_mod_path, use_tree, _is_glob, _alias| {
+                            if cur == *index {
+                                tree = Some(use_tree.clone());
+                            }
+                            cur += 1;
+                        },
+                    );
+                    if let Some(tree) = tree {
+                        sink.push(UnresolvedImport { file: ast.file_id, node: AstPtr::new(&tree) });
+                    }
+                }
            }
        }
    }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 3e99c8773..100e25ffc 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -3,8 +3,11 @@
 //! `DefCollector::collect` contains the fixed-point iteration loop which
 //! resolves imports and expands macros.
+use std::iter;
 use base_db::{CrateId, FileId, ProcMacroId};
 use cfg::CfgOptions;
+use hir_expand::InFile;
 use hir_expand::{
    ast_id_map::FileAstId,
    builtin_derive::find_builtin_derive,
@@ -13,17 +16,16 @@ use hir_expand::{
    proc_macro::ProcMacroExpander,
    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ast;
 use test_utils::mark;
+use tt::{Leaf, TokenTree};
 use crate::{
    attr::Attrs,
    db::DefDatabase,
    item_scope::{ImportType, PerNsGlobImports},
-    item_tree::{
+    item_tree::{self, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind},
-        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind,
-    },
    nameres::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
        BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
@@ -85,6 +87,7 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> Cr
        mod_dirs: FxHashMap::default(),
        cfg_options,
        proc_macros,
+        exports_proc_macros: false,
        from_glob_import: Default::default(),
    };
    collector.collect();
@@ -112,6 +115,12 @@ impl PartialResolvedImport {
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
+enum ImportSource {
+    Import(ItemTreeId<item_tree::Import>),
+    ExternCrate(ItemTreeId<item_tree::ExternCrate>),
+}
+#[derive(Clone, Debug, Eq, PartialEq)]
 struct Import {
    pub path: ModPath,
    pub alias: Option<ImportAlias>,
@@ -120,11 +129,12 @@ struct Import {
    pub is_prelude: bool,
    pub is_extern_crate: bool,
    pub is_macro_use: bool,
+    source: ImportSource,
 }
 impl Import {
-    fn from_use(tree: &ItemTree, id: FileItemTreeId<item_tree::Import>) -> Self {
+    fn from_use(tree: &ItemTree, id: ItemTreeId<item_tree::Import>) -> Self {
-        let it = &tree[id];
+        let it = &tree[id.value];
        let visibility = &tree[it.visibility];
        Self {
            path: it.path.clone(),
@@ -134,20 +144,22 @@ impl Import {
            is_prelude: it.is_prelude,
            is_extern_crate: false,
            is_macro_use: false,
+            source: ImportSource::Import(id),
        }
    }
-    fn from_extern_crate(tree: &ItemTree, id: FileItemTreeId<item_tree::ExternCrate>) -> Self {
+    fn from_extern_crate(tree: &ItemTree, id: ItemTreeId<item_tree::ExternCrate>) -> Self {
-        let it = &tree[id];
+        let it = &tree[id.value];
        let visibility = &tree[it.visibility];
        Self {
-            path: it.path.clone(),
+            path: ModPath::from_segments(PathKind::Plain, iter::once(it.name.clone())),
            alias: it.alias.clone(),
            visibility: visibility.clone(),
            is_glob: false,
            is_prelude: false,
            is_extern_crate: true,
            is_macro_use: it.is_macro_use,
+            source: ImportSource::ExternCrate(id),
        }
    }
 }
@@ -191,7 +203,12 @@ struct DefCollector<'a> {
    unexpanded_attribute_macros: Vec<DeriveDirective>,
    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
    cfg_options: &'a CfgOptions,
+    /// List of procedural macros defined by this crate. This is read from the dynamic library
+    /// built by the build system, and is the list of proc. macros we can actually expand. It is
+    /// empty when proc. macro support is disabled (in which case we still do name resolution for
+    /// them).
    proc_macros: Vec<(Name, ProcMacroExpander)>,
+    exports_proc_macros: bool,
    from_glob_import: PerNsGlobImports,
 }
@@ -245,28 +262,61 @@ impl DefCollector<'_> {
        let unresolved_imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
        // show unresolved imports in completion, etc
-        for directive in unresolved_imports {
+        for directive in &unresolved_imports {
-            self.record_resolved_import(&directive)
+            self.record_resolved_import(directive)
+        }
+        self.unresolved_imports = unresolved_imports;
+        // FIXME: This condition should instead check if this is a `proc-macro` type crate.
+        if self.exports_proc_macros {
+            // A crate exporting procedural macros is not allowed to export anything else.
+            //
+            // Additionally, while the proc macro entry points must be `pub`, they are not publicly
+            // exported in type/value namespace. This function reduces the visibility of all items
+            // in the crate root that aren't proc macros.
+            let root = self.def_map.root;
+            let root = &mut self.def_map.modules[root];
+            root.scope.censor_non_proc_macros(ModuleId {
+                krate: self.def_map.krate,
+                local_id: self.def_map.root,
+            });
        }
-        // Record proc-macros
-        self.collect_proc_macro();
    }
-    fn collect_proc_macro(&mut self) {
+    /// Adds a definition of procedural macro `name` to the root module.
-        let proc_macros = std::mem::take(&mut self.proc_macros);
+    ///
-        for (name, expander) in proc_macros {
+    /// # Notes on procedural macro resolution
-            let krate = self.def_map.krate;
+    ///
+    /// Procedural macro functionality is provided by the build system: It has to build the proc
-            let macro_id = MacroDefId {
+    /// macro and pass the resulting dynamic library to rust-analyzer.
+    ///
+    /// When procedural macro support is enabled, the list of proc macros exported by a crate is
+    /// known before we resolve names in the crate. This list is stored in `self.proc_macros` and is
+    /// derived from the dynamic library.
+    ///
+    /// However, we *also* would like to be able to at least *resolve* macros on our own, without
+    /// help by the build system. So, when the macro isn't found in `self.proc_macros`, we instead
+    /// use a dummy expander that always errors. This comes with the drawback of macros potentially
+    /// going out of sync with what the build system sees (since we resolve using VFS state, but
+    /// Cargo builds only on-disk files). We could and probably should add diagnostics for that.
+    fn resolve_proc_macro(&mut self, name: &Name) {
+        self.exports_proc_macros = true;
+        let macro_def = match self.proc_macros.iter().find(|(n, _)| n == name) {
+            Some((_, expander)) => MacroDefId {
                ast_id: None,
-                krate: Some(krate),
+                krate: Some(self.def_map.krate),
-                kind: MacroDefKind::CustomDerive(expander),
+                kind: MacroDefKind::ProcMacro(*expander),
                local_inner: false,
-            };
+            },
+            None => MacroDefId {
+                ast_id: None,
+                krate: Some(self.def_map.krate),
+                kind: MacroDefKind::ProcMacro(ProcMacroExpander::dummy(self.def_map.krate)),
+                local_inner: false,
+            },
+        };
-            self.define_proc_macro(name.clone(), macro_id);
+        self.define_proc_macro(name.clone(), macro_def);
-        }
    }
    /// Define a macro with `macro_rules`.
@@ -346,20 +396,15 @@ impl DefCollector<'_> {
    fn import_macros_from_extern_crate(
        &mut self,
        current_module_id: LocalModuleId,
-        import: &item_tree::ExternCrate,
+        extern_crate: &item_tree::ExternCrate,
    ) {
        log::debug!(
            "importing macros from extern crate: {:?} ({:?})",
-            import,
+            extern_crate,
            self.def_map.edition,
        );
-        let res = self.def_map.resolve_name_in_extern_prelude(
+        let res = self.def_map.resolve_name_in_extern_prelude(&extern_crate.name);
-            &import
-                .path
-                .as_ident()
-                .expect("extern crate should have been desugared to one-element path"),
-        );
        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
            mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
@@ -420,7 +465,11 @@ impl DefCollector<'_> {
                    .as_ident()
                    .expect("extern crate should have been desugared to one-element path"),
            );
-            PartialResolvedImport::Resolved(res)
+            if res.is_none() {
+                PartialResolvedImport::Unresolved
+            } else {
+                PartialResolvedImport::Resolved(res)
+            }
        } else {
            let res = self.def_map.resolve_path_fp_with_macro(
                self.db,
@@ -774,7 +823,51 @@ impl DefCollector<'_> {
        .collect(item_tree.top_level_items());
    }
-    fn finish(self) -> CrateDefMap {
+    fn finish(mut self) -> CrateDefMap {
+        // Emit diagnostics for all remaining unresolved imports.
+        // We'd like to avoid emitting a diagnostics avalanche when some `extern crate` doesn't
+        // resolve. We first emit diagnostics for unresolved extern crates and collect the missing
+        // crate names. Then we emit diagnostics for unresolved imports, but only if the import
+        // doesn't start with an unresolved crate's name. Due to renaming and reexports, this is a
+        // heuristic, but it works in practice.
+        let mut diagnosed_extern_crates = FxHashSet::default();
+        for directive in &self.unresolved_imports {
+            if let ImportSource::ExternCrate(krate) = directive.import.source {
+                let item_tree = self.db.item_tree(krate.file_id);
+                let extern_crate = &item_tree[krate.value];
+                diagnosed_extern_crates.insert(extern_crate.name.clone());
+                self.def_map.diagnostics.push(DefDiagnostic::unresolved_extern_crate(
+                    directive.module_id,
+                    InFile::new(krate.file_id, extern_crate.ast_id),
+                ));
+            }
+        }
+        for directive in &self.unresolved_imports {
+            if let ImportSource::Import(import) = &directive.import.source {
+                let item_tree = self.db.item_tree(import.file_id);
+                let import_data = &item_tree[import.value];
+                match (import_data.path.segments.first(), &import_data.path.kind) {
+                    (Some(krate), PathKind::Plain) | (Some(krate), PathKind::Abs) => {
+                        if diagnosed_extern_crates.contains(krate) {
+                            continue;
+                        }
+                    }
+                    _ => {}
+                }
+                self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(
+                    directive.module_id,
+                    InFile::new(import.file_id, import_data.ast_id),
+                    import_data.index,
+                ));
+            }
+        }
        self.def_map
    }
 }
@@ -819,178 +912,186 @@ impl ModCollector<'_, '_> {
        for &item in items {
            let attrs = self.item_tree.attrs(item.into());
-            if self.is_cfg_enabled(attrs) {
+            if !self.is_cfg_enabled(attrs) {
-                let module =
+                continue;
-                    ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
+            }
-                let container = ContainerId::ModuleId(module);
+            let module =
+                ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
-                let mut def = None;
+            let container = ContainerId::ModuleId(module);
-                match item {
-                    ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
+            let mut def = None;
-                    ModItem::Import(import_id) => {
+            match item {
-                        self.def_collector.unresolved_imports.push(ImportDirective {
+                ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
-                            module_id: self.module_id,
+                ModItem::Import(import_id) => {
-                            import: Import::from_use(&self.item_tree, import_id),
+                    self.def_collector.unresolved_imports.push(ImportDirective {
-                            status: PartialResolvedImport::Unresolved,
+                        module_id: self.module_id,
-                        })
+                        import: Import::from_use(
-                    }
+                            &self.item_tree,
-                    ModItem::ExternCrate(import_id) => {
+                            InFile::new(self.file_id, import_id),
-                        self.def_collector.unresolved_imports.push(ImportDirective {
+                        ),
-                            module_id: self.module_id,
+                        status: PartialResolvedImport::Unresolved,
-                            import: Import::from_extern_crate(&self.item_tree, import_id),
+                    })
-                            status: PartialResolvedImport::Unresolved,
+                }
-                        })
+                ModItem::ExternCrate(import_id) => {
-                    }
+                    self.def_collector.unresolved_imports.push(ImportDirective {
-                    ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
+                        module_id: self.module_id,
-                    ModItem::Impl(imp) => {
+                        import: Import::from_extern_crate(
-                        let module = ModuleId {
+                            &self.item_tree,
-                            krate: self.def_collector.def_map.krate,
+                            InFile::new(self.file_id, import_id),
-                            local_id: self.module_id,
+                        ),
-                        };
+                        status: PartialResolvedImport::Unresolved,
-                        let container = ContainerId::ModuleId(module);
+                    })
-                        let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
+                }
-                            .intern(self.def_collector.db);
+                ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
-                        self.def_collector.def_map.modules[self.module_id]
+                ModItem::Impl(imp) => {
-                            .scope
+                    let module = ModuleId {
-                            .define_impl(impl_id)
+                        krate: self.def_collector.def_map.krate,
-                    }
+                        local_id: self.module_id,
-                    ModItem::Function(id) => {
+                    };
-                        let func = &self.item_tree[id];
+                    let container = ContainerId::ModuleId(module);
-                        def = Some(DefData {
+                    let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
-                            id: FunctionLoc {
+                        .intern(self.def_collector.db);
-                                container: container.into(),
+                    self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
-                                id: ItemTreeId::new(self.file_id, id),
+                }
-                            }
+                ModItem::Function(id) => {
-                            .intern(self.def_collector.db)
+                    let func = &self.item_tree[id];
-                            .into(),
-                            name: &func.name,
-                            visibility: &self.item_tree[func.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Struct(id) => {
-                        let it = &self.item_tree[id];
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                    self.collect_proc_macro_def(&func.name, attrs);
-                        // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: FunctionLoc {
-                                .intern(self.def_collector.db)
+                            container: container.into(),
-                                .into(),
+                            id: ItemTreeId::new(self.file_id, id),
-                            name: &it.name,
+                        }
-                            visibility: &self.item_tree[it.visibility],
+                        .intern(self.def_collector.db)
-                            has_constructor: it.kind != StructDefKind::Record,
+                        .into(),
-                        });
+                        name: &func.name,
-                    }
+                        visibility: &self.item_tree[func.visibility],
-                    ModItem::Union(id) => {
+                        has_constructor: false,
-                        let it = &self.item_tree[id];
+                    });
+                }
+                ModItem::Struct(id) => {
+                    let it = &self.item_tree[id];
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
+                    // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
+                    // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(attrs, it.ast_id.upcast());
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
+                            .intern(self.def_collector.db)
-                                .into(),
+                            .into(),
-                            name: &it.name,
+                        name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
+                        visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
+                        has_constructor: it.kind != StructDefKind::Record,
-                        });
+                    });
-                    }
+                }
-                    ModItem::Enum(id) => {
+                ModItem::Union(id) => {
-                        let it = &self.item_tree[id];
+                    let it = &self.item_tree[id];
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
+                    // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
+                    // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                    self.collect_derives(attrs, it.ast_id.upcast());
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
+                            .intern(self.def_collector.db)
-                                .into(),
+                            .into(),
-                            name: &it.name,
+                        name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
+                        visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
+                        has_constructor: false,
-                        });
+                    });
-                    }
+                }
-                    ModItem::Const(id) => {
+                ModItem::Enum(id) => {
-                        let it = &self.item_tree[id];
+                    let it = &self.item_tree[id];
-                        if let Some(name) = &it.name {
-                            def = Some(DefData {
-                                id: ConstLoc {
-                                    container: container.into(),
-                                    id: ItemTreeId::new(self.file_id, id),
-                                }
-                                .intern(self.def_collector.db)
-                                .into(),
-                                name,
-                                visibility: &self.item_tree[it.visibility],
-                                has_constructor: false,
-                            });
-                        }
-                    }
-                    ModItem::Static(id) => {
-                        let it = &self.item_tree[id];
-                        def = Some(DefData {
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
-                            id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                    // in which case we don't add the invocation, just a single attribute
-                                .intern(self.def_collector.db)
+                    // macro invocation
-                                .into(),
+                    self.collect_derives(attrs, it.ast_id.upcast());
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Trait(id) => {
-                        let it = &self.item_tree[id];
-                        def = Some(DefData {
+                    def = Some(DefData {
-                            id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
+                            .intern(self.def_collector.db)
-                                .into(),
+                            .into(),
-                            name: &it.name,
+                        name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
+                        visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
+                        has_constructor: false,
-                        });
+                    });
-                    }
+                }
-                    ModItem::TypeAlias(id) => {
+                ModItem::Const(id) => {
-                        let it = &self.item_tree[id];
+                    let it = &self.item_tree[id];
+                    if let Some(name) = &it.name {
                        def = Some(DefData {
-                            id: TypeAliasLoc {
+                            id: ConstLoc {
                                container: container.into(),
                                id: ItemTreeId::new(self.file_id, id),
                            }
                            .intern(self.def_collector.db)
                            .into(),
-                            name: &it.name,
+                            name,
                            visibility: &self.item_tree[it.visibility],
                            has_constructor: false,
                        });
                    }
                }
+                ModItem::Static(id) => {
+                    let it = &self.item_tree[id];
-                if let Some(DefData { id, name, visibility, has_constructor }) = def {
+                    def = Some(DefData {
-                    self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
+                        id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                    let vis = self
+                            .intern(self.def_collector.db)
-                        .def_collector
+                            .into(),
-                        .def_map
+                        name: &it.name,
-                        .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+                        visibility: &self.item_tree[it.visibility],
-                        .unwrap_or(Visibility::Public);
+                        has_constructor: false,
-                    self.def_collector.update(
+                    });
-                        self.module_id,
+                }
-                        &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
+                ModItem::Trait(id) => {
-                        vis,
+                    let it = &self.item_tree[id];
-                        ImportType::Named,
-                    )
+                    def = Some(DefData {
+                        id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
                }
+                ModItem::TypeAlias(id) => {
+                    let it = &self.item_tree[id];
+                    def = Some(DefData {
+                        id: TypeAliasLoc {
+                            container: container.into(),
+                            id: ItemTreeId::new(self.file_id, id),
+                        }
+                        .intern(self.def_collector.db)
+                        .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
+                }
+            }
+            if let Some(DefData { id, name, visibility, has_constructor }) = def {
+                self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
+                let vis = self
+                    .def_collector
+                    .def_map
+                    .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+                    .unwrap_or(Visibility::Public);
+                self.def_collector.update(
+                    self.module_id,
+                    &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
+                    vis,
+                    ImportType::Named,
+                )
            }
        }
    }
@@ -1051,13 +1152,11 @@ impl ModCollector<'_, '_> {
                            self.import_all_legacy_macros(module_id);
                        }
                    }
-                    Err(candidate) => self.def_collector.def_map.diagnostics.push(
+                    Err(candidate) => {
-                        DefDiagnostic::UnresolvedModule {
+                        self.def_collector.def_map.diagnostics.push(
-                            module: self.module_id,
+                            DefDiagnostic::unresolved_module(self.module_id, ast_id, candidate),
-                            declaration: ast_id,
+                        );
-                            candidate,
+                    }
-                        },
-                    ),
                };
            }
        }
@@ -1119,6 +1218,30 @@ impl ModCollector<'_, '_> {
        }
    }
+    /// If `attrs` registers a procedural macro, collects its definition.
+    fn collect_proc_macro_def(&mut self, func_name: &Name, attrs: &Attrs) {
+        // FIXME: this should only be done in the root module of `proc-macro` crates, not everywhere
+        // FIXME: distinguish the type of macro
+        let macro_name = if attrs.by_key("proc_macro").exists()
+            || attrs.by_key("proc_macro_attribute").exists()
+        {
+            func_name.clone()
+        } else {
+            let derive = attrs.by_key("proc_macro_derive");
+            if let Some(arg) = derive.tt_values().next() {
+                if let [TokenTree::Leaf(Leaf::Ident(trait_name))] = &*arg.token_trees {
+                    trait_name.as_name()
+                } else {
+                    return;
+                }
+            } else {
+                return;
+            }
+        };
+        self.def_collector.resolve_proc_macro(&macro_name);
+    }
    fn collect_macro(&mut self, mac: &MacroCall) {
        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
@@ -1225,6 +1348,7 @@ mod tests {
            mod_dirs: FxHashMap::default(),
            cfg_options: &CfgOptions::default(),
            proc_macros: Default::default(),
+            exports_proc_macros: false,
            from_glob_import: Default::default(),
        };
        collector.collect();
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 5ca30dac9..11d84f808 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -2,6 +2,7 @@ mod globs;
 mod incremental;
 mod macros;
 mod mod_resolution;
+mod diagnostics;
 mod primitives;
 use std::sync::Arc;
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
new file mode 100644
index 000000000..576b813d2
--- /dev/null
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -0,0 +1,131 @@
+use base_db::fixture::WithFixture;
+use base_db::FileId;
+use base_db::SourceDatabaseExt;
+use hir_expand::db::AstDatabase;
+use rustc_hash::FxHashMap;
+use syntax::TextRange;
+use syntax::TextSize;
+use crate::test_db::TestDB;
+fn check_diagnostics(ra_fixture: &str) {
+    let db: TestDB = TestDB::with_files(ra_fixture);
+    let annotations = db.extract_annotations();
+    assert!(!annotations.is_empty());
+    let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
+    db.diagnostics(|d| {
+        let src = d.display_source();
+        let root = db.parse_or_expand(src.file_id).unwrap();
+        // FIXME: macros...
+        let file_id = src.file_id.original_file(&db);
+        let range = src.value.to_node(&root).text_range();
+        let message = d.message().to_owned();
+        actual.entry(file_id).or_default().push((range, message));
+    });
+    for (file_id, diags) in actual.iter_mut() {
+        diags.sort_by_key(|it| it.0.start());
+        let text = db.file_text(*file_id);
+        // For multiline spans, place them on line start
+        for (range, content) in diags {
+            if text[*range].contains('\n') {
+                *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
+                *content = format!("... {}", content);
+            }
+        }
+    }
+    assert_eq!(annotations, actual);
+}
+#[test]
+fn unresolved_import() {
+    check_diagnostics(
+        r"
+        use does_exist;
+        use does_not_exist;
+          //^^^^^^^^^^^^^^ unresolved import
+        mod does_exist {}
+        ",
+    );
+}
+#[test]
+fn unresolved_import_in_use_tree() {
+    // Only the relevant part of a nested `use` item should be highlighted.
+    check_diagnostics(
+        r"
+        use does_exist::{Exists, DoesntExist};
+                               //^^^^^^^^^^^ unresolved import
+        use {does_not_exist::*, does_exist};
+           //^^^^^^^^^^^^^^^^^ unresolved import
+        use does_not_exist::{
+            a,
+          //^ unresolved import
+            b,
+          //^ unresolved import
+            c,
+          //^ unresolved import
+        };
+        mod does_exist {
+            pub struct Exists;
+        }
+        ",
+    );
+}
+#[test]
+fn unresolved_extern_crate() {
+    check_diagnostics(
+        r"
+        //- /main.rs crate:main deps:core
+        extern crate core;
+          extern crate doesnotexist;
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+        //- /lib.rs crate:core
+        ",
+    );
+}
+#[test]
+fn dedup_unresolved_import_from_unresolved_crate() {
+    check_diagnostics(
+        r"
+        //- /main.rs crate:main
+        mod a {
+            extern crate doesnotexist;
+          //^^^^^^^^^^^^^^^^^^^^^^^^^^ unresolved extern crate
+            // Should not error, since we already errored for the missing crate.
+            use doesnotexist::{self, bla, *};
+            use crate::doesnotexist;
+              //^^^^^^^^^^^^^^^^^^^ unresolved import
+        }
+        mod m {
+            use super::doesnotexist;
+              //^^^^^^^^^^^^^^^^^^^ unresolved import
+        }
+        ",
+    );
+}
+#[test]
+fn unresolved_module() {
+    check_diagnostics(
+        r"
+        //- /lib.rs
+        mod foo;
+          mod bar;
+        //^^^^^^^^ unresolved module
+        mod baz {}
+        //- /foo.rs
+        ",
+    );
+}
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index e0fb8bdef..0851c3b7d 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -667,3 +667,76 @@ b! { static = #[] (); }
        "#]],
    );
 }
+#[test]
+fn resolves_proc_macros() {
+    check(
+        r"
+        struct TokenStream;
+        #[proc_macro]
+        pub fn function_like_macro(args: TokenStream) -> TokenStream {
+            args
+        }
+        #[proc_macro_attribute]
+        pub fn attribute_macro(_args: TokenStream, item: TokenStream) -> TokenStream {
+            item
+        }
+        #[proc_macro_derive(DummyTrait)]
+        pub fn derive_macro(_item: TokenStream) -> TokenStream {
+            TokenStream
+        }
+        ",
+        expect![[r#"
+            crate
+            DummyTrait: m
+            TokenStream: t v
+            attribute_macro: v m
+            derive_macro: v
+            function_like_macro: v m
+        "#]],
+    );
+}
+#[test]
+fn proc_macro_censoring() {
+    // Make sure that only proc macros are publicly exported from proc-macro crates.
+    check(
+        r"
+        //- /main.rs crate:main deps:macros
+        pub use macros::*;
+        //- /macros.rs crate:macros
+        pub struct TokenStream;
+        #[proc_macro]
+        pub fn function_like_macro(args: TokenStream) -> TokenStream {
+            args
+        }
+        #[proc_macro_attribute]
+        pub fn attribute_macro(_args: TokenStream, item: TokenStream) -> TokenStream {
+            item
+        }
+        #[proc_macro_derive(DummyTrait)]
+        pub fn derive_macro(_item: TokenStream) -> TokenStream {
+            TokenStream
+        }
+        #[macro_export]
+        macro_rules! mbe {
+            () => {};
+        }
+        ",
+        expect![[r#"
+            crate
+            DummyTrait: m
+            attribute_macro: m
+            function_like_macro: m
+        "#]],
+    );
+}
diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs
index 1f619787e..f93337a6e 100644
--- a/crates/hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs
@@ -672,42 +672,6 @@ pub struct Baz;
 }
 #[test]
-fn unresolved_module_diagnostics() {
-    let db = TestDB::with_files(
-        r"
-        //- /lib.rs
-        mod foo;
-        mod bar;
-        mod baz {}
-        //- /foo.rs
-        ",
-    );
-    let krate = db.test_crate();
-    let crate_def_map = db.crate_def_map(krate);
-    expect![[r#"
-        [
-            UnresolvedModule {
-                module: Idx::<ModuleData>(0),
-                declaration: InFile {
-                    file_id: HirFileId(
-                        FileId(
-                            FileId(
-                                0,
-                            ),
-                        ),
-                    ),
-                    value: FileAstId::<syntax::ast::generated::nodes::Module>(1),
-                },
-                candidate: "bar.rs",
-            },
-        ]
-    "#]]
-    .assert_debug_eq(&crate_def_map.diagnostics);
-}
-#[test]
 fn module_resolution_decl_inside_module_in_non_crate_root_2() {
    check(
        r#"
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 40ec38f56..209b18e78 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -56,10 +56,6 @@ impl ModPath {
        ModPath { kind, segments }
    }
-    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> ModPath {
-        name_ref.as_name().into()
-    }
    /// Converts an `tt::Ident` into a single-identifier `Path`.
    pub(crate) fn from_tt_ident(ident: &tt::Ident) -> ModPath {
        ident.as_name().into()
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index 42a762936..fb1d3c974 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -5,9 +5,15 @@ use std::{
    sync::{Arc, Mutex},
 };
+use base_db::SourceDatabase;
 use base_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, Upcast};
 use hir_expand::db::AstDatabase;
+use hir_expand::diagnostics::Diagnostic;
+use hir_expand::diagnostics::DiagnosticSinkBuilder;
+use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
+use syntax::TextRange;
+use test_utils::extract_annotations;
 use crate::db::DefDatabase;
@@ -98,4 +104,40 @@ impl TestDB {
            })
            .collect()
    }
+    pub fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
+        let mut files = Vec::new();
+        let crate_graph = self.crate_graph();
+        for krate in crate_graph.iter() {
+            let crate_def_map = self.crate_def_map(krate);
+            for (module_id, _) in crate_def_map.modules.iter() {
+                let file_id = crate_def_map[module_id].origin.file_id();
+                files.extend(file_id)
+            }
+        }
+        assert!(!files.is_empty());
+        files
+            .into_iter()
+            .filter_map(|file_id| {
+                let text = self.file_text(file_id);
+                let annotations = extract_annotations(&text);
+                if annotations.is_empty() {
+                    return None;
+                }
+                Some((file_id, annotations))
+            })
+            .collect()
+    }
+    pub fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+        let crate_graph = self.crate_graph();
+        for krate in crate_graph.iter() {
+            let crate_def_map = self.crate_def_map(krate);
+            let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
+            for (module_id, _) in crate_def_map.modules.iter() {
+                crate_def_map.add_diagnostics(self, module_id, &mut sink);
+            }
+        }
+    }
 }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 710694a34..b591130ca 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -143,7 +143,7 @@ pub(crate) fn macro_def(
            Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
        }
        MacroDefKind::BuiltInEager(_) => None,
-        MacroDefKind::CustomDerive(expander) => {
+        MacroDefKind::ProcMacro(expander) => {
            Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
        }
    }
@@ -249,7 +249,7 @@ pub(crate) fn expand_proc_macro(
    };
    let expander = match loc.def.kind {
-        MacroDefKind::CustomDerive(expander) => expander,
+        MacroDefKind::ProcMacro(expander) => expander,
        _ => unreachable!(),
    };
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 10c45646f..2f37d7189 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -129,7 +129,7 @@ fn eager_macro_recur(
            MacroDefKind::Declarative
            | MacroDefKind::BuiltIn(_)
            | MacroDefKind::BuiltInDerive(_)
-            | MacroDefKind::CustomDerive(_) => {
+            | MacroDefKind::ProcMacro(_) => {
                let expanded = lazy_expand(db, &def, curr.with_value(child.clone()), krate)?;
                // replace macro inside
                eager_macro_recur(db, expanded, krate, macro_resolver)?
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 845e9cbc1..d383b968d 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -33,7 +33,7 @@ impl Hygiene {
                        MacroDefKind::BuiltIn(_) => (None, false),
                        MacroDefKind::BuiltInDerive(_) => (None, false),
                        MacroDefKind::BuiltInEager(_) => (None, false),
-                        MacroDefKind::CustomDerive(_) => (None, false),
+                        MacroDefKind::ProcMacro(_) => (None, false),
                    }
                }
                MacroCallId::EagerMacro(_id) => (None, false),
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 2be15e841..17f1178ed 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -246,7 +246,7 @@ pub enum MacroDefKind {
    // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
    BuiltInDerive(BuiltinDeriveExpander),
    BuiltInEager(EagerExpander),
-    CustomDerive(ProcMacroExpander),
+    ProcMacro(ProcMacroExpander),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 49841c7a1..a5750d829 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -43,8 +43,8 @@ impl Name {
    }
    /// Shortcut to create inline plain text name
-    const fn new_inline_ascii(text: &[u8]) -> Name {
+    const fn new_inline(text: &str) -> Name {
-        Name::new_text(SmolStr::new_inline_from_ascii(text.len(), text))
+        Name::new_text(SmolStr::new_inline(text))
    }
    /// Resolve a name from the text of token.
@@ -127,7 +127,7 @@ pub mod known {
            $(
                #[allow(bad_style)]
                pub const $ident: super::Name =
-                    super::Name::new_inline_ascii(stringify!($ident).as_bytes());
+                    super::Name::new_inline(stringify!($ident));
            )*
        };
    }
@@ -210,8 +210,8 @@ pub mod known {
    );
    // self/Self cannot be used as an identifier
-    pub const SELF_PARAM: super::Name = super::Name::new_inline_ascii(b"self");
+    pub const SELF_PARAM: super::Name = super::Name::new_inline("self");
-    pub const SELF_TYPE: super::Name = super::Name::new_inline_ascii(b"Self");
+    pub const SELF_TYPE: super::Name = super::Name::new_inline("Self");
    #[macro_export]
    macro_rules! name {
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 80255ea32..7505cb061 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -7,7 +7,7 @@ use tt::buffer::{Cursor, TokenBuffer};
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub struct ProcMacroExpander {
    krate: CrateId,
-    proc_macro_id: ProcMacroId,
+    proc_macro_id: Option<ProcMacroId>,
 }
 macro_rules! err {
@@ -20,8 +20,14 @@ macro_rules! err {
 }
 impl ProcMacroExpander {
-    pub fn new(krate: CrateId, proc_macro_id: ProcMacroId) -> ProcMacroExpander {
+    pub fn new(krate: CrateId, proc_macro_id: ProcMacroId) -> Self {
-        ProcMacroExpander { krate, proc_macro_id }
+        Self { krate, proc_macro_id: Some(proc_macro_id) }
+    }
+    pub fn dummy(krate: CrateId) -> Self {
+        // FIXME: Should store the name for better errors
+        // FIXME: I think this is the second layer of "dummy" expansion, we should reduce that
+        Self { krate, proc_macro_id: None }
    }
    pub fn expand(
@@ -30,17 +36,22 @@ impl ProcMacroExpander {
        _id: LazyMacroId,
        tt: &tt::Subtree,
    ) -> Result<tt::Subtree, mbe::ExpandError> {
-        let krate_graph = db.crate_graph();
+        match self.proc_macro_id {
-        let proc_macro = krate_graph[self.krate]
+            Some(id) => {
-            .proc_macro
+                let krate_graph = db.crate_graph();
-            .get(self.proc_macro_id.0 as usize)
+                let proc_macro = krate_graph[self.krate]
-            .clone()
+                    .proc_macro
-            .ok_or_else(|| err!("No derive macro found."))?;
+                    .get(id.0 as usize)
+                    .clone()
-        let tt = remove_derive_attrs(tt)
+                    .ok_or_else(|| err!("No derive macro found."))?;
-            .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
+                let tt = remove_derive_attrs(tt)
-        proc_macro.expander.expand(&tt, None).map_err(mbe::ExpandError::from)
+                    .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
+                proc_macro.expander.expand(&tt, None).map_err(mbe::ExpandError::from)
+            }
+            None => Err(err!("Unresolved proc macro")),
+        }
    }