14 files changed, 855 insertions, 295 deletions
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);
+            }
+        }
+    }
 }