14 files changed, 571 insertions, 246 deletions
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 30ac12a12..2d91bb21f 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -239,7 +239,10 @@ impl ExprCollector<'_> {
                    None => self.missing_expr(),
                },
                // FIXME: we need to record these effects somewhere...
-                ast::Effect::Async(_) => self.collect_block_opt(e.block_expr()),
+                ast::Effect::Async(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::Async { body }, syntax_ptr)
+                }
            },
            ast::Expr::BlockExpr(e) => self.collect_block(e),
            ast::Expr::LoopExpr(e) => {
@@ -835,8 +838,12 @@ impl ExprCollector<'_> {
                Pat::Missing
            }
+            ast::Pat::BoxPat(boxpat) => {
+                let inner = self.collect_pat_opt(boxpat.pat());
+                Pat::Box { inner }
+            }
            // FIXME: implement
-            ast::Pat::BoxPat(_) | ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
+            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
        };
        let ptr = AstPtr::new(&pat);
        self.alloc_pat(pattern, Either::Left(ptr))
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 9a8eb4ede..6190906da 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -54,6 +54,7 @@ pub struct TypeAliasData {
    pub name: Name,
    pub type_ref: Option<TypeRef>,
    pub visibility: RawVisibility,
+    pub is_extern: bool,
    /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
    pub bounds: Vec<TypeBound>,
 }
@@ -71,6 +72,7 @@ impl TypeAliasData {
            name: typ.name.clone(),
            type_ref: typ.type_ref.clone(),
            visibility: item_tree[typ.visibility].clone(),
+            is_extern: typ.is_extern,
            bounds: typ.bounds.to_vec(),
        })
    }
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index 3e19d9117..2ec0fd3fb 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -28,3 +28,45 @@ 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
+    }
+}
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index c94b3a36f..e5d740a36 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -111,6 +111,9 @@ pub enum Expr {
    TryBlock {
        body: ExprId,
    },
+    Async {
+        body: ExprId,
+    },
    Cast {
        expr: ExprId,
        type_ref: TypeRef,
@@ -250,7 +253,7 @@ impl Expr {
                    f(*expr);
                }
            }
-            Expr::TryBlock { body } | Expr::Unsafe { body } => f(*body),
+            Expr::TryBlock { body } | Expr::Unsafe { body } | Expr::Async { body } => f(*body),
            Expr::Loop { body, .. } => f(*body),
            Expr::While { condition, body, .. } => {
                f(*condition);
@@ -395,6 +398,7 @@ pub enum Pat {
    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
    Ref { pat: PatId, mutability: Mutability },
+    Box { inner: PatId },
 }
 impl Pat {
@@ -415,6 +419,7 @@ impl Pat {
            Pat::Record { args, .. } => {
                args.iter().map(|f| f.pat).for_each(f);
            }
+            Pat::Box { inner } => f(*inner),
        }
    }
 }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index e14722cae..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 ...`.
@@ -592,6 +596,7 @@ pub struct TypeAlias {
    pub bounds: Box<[TypeBound]>,
    pub generic_params: GenericParamsId,
    pub type_ref: Option<TypeRef>,
+    pub is_extern: bool,
    pub ast_id: FileAstId<ast::TypeAlias>,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 6a503d785..54814f141 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -364,6 +364,7 @@ impl Ctx {
            generic_params,
            type_ref,
            ast_id,
+            is_extern: false,
        };
        Some(id(self.data().type_aliases.alloc(res)))
    }
@@ -482,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,
@@ -490,6 +491,7 @@ impl Ctx {
                    is_glob,
                    is_prelude,
                    ast_id,
+                    index: imports.len(),
                })));
            },
        );
@@ -501,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)
        });
@@ -510,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)))
    }
@@ -558,8 +560,9 @@ impl Ctx {
                            statik.into()
                        }
                        ast::ExternItem::TypeAlias(ty) => {
-                            let id = self.lower_type_alias(&ty)?;
+                            let foreign_ty = self.lower_type_alias(&ty)?;
-                            id.into()
+                            self.data().type_aliases[foreign_ty.index].is_extern = true;
+                            foreign_ty.into()
                        }
                        ast::ExternItem::MacroCall(_) => return None,
                    };
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
index 620e697d4..1a806cda5 100644
--- a/crates/hir_def/src/item_tree/tests.rs
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -228,15 +228,15 @@ 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 }]) }]
-            > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, ast_id: FileAstId::<syntax::ast::generated::nodes::TypeAlias>(8) }
+            > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, is_extern: false, ast_id: FileAstId::<syntax::ast::generated::nodes::TypeAlias>(8) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_const"))] }, input: None }]) }]
            > Const { name: Some(Name(Text("CONST"))), visibility: RawVisibilityId("pub(self)"), type_ref: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("u8"))] }, generic_args: [None] }), ast_id: FileAstId::<syntax::ast::generated::nodes::Const>(9) }
            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_method"))] }, 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..4c3993ff0 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,
@@ -14,6 +17,7 @@ use hir_expand::{
    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
 use rustc_hash::FxHashMap;
+use rustc_hash::FxHashSet;
 use syntax::ast;
 use test_utils::mark;
@@ -21,9 +25,7 @@ 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,
@@ -112,6 +114,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 +128,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 +143,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),
        }
    }
 }
@@ -245,9 +256,10 @@ 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;
        // Record proc-macros
        self.collect_proc_macro();
@@ -261,7 +273,7 @@ impl DefCollector<'_> {
            let macro_id = MacroDefId {
                ast_id: None,
                krate: Some(krate),
-                kind: MacroDefKind::CustomDerive(expander),
+                kind: MacroDefKind::ProcMacro(expander),
                local_inner: false,
            };
@@ -346,20 +358,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 +427,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 +785,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,179 +874,184 @@ 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(),
+                    def = Some(DefData {
-                            name: &func.name,
+                        id: FunctionLoc {
-                            visibility: &self.item_tree[func.visibility],
+                            container: container.into(),
-                            has_constructor: false,
+                            id: ItemTreeId::new(self.file_id, id),
-                        });
+                        }
-                    }
+                        .intern(self.def_collector.db)
-                    ModItem::Struct(id) => {
+                        .into(),
-                        let it = &self.item_tree[id];
+                        name: &func.name,
+                        visibility: &self.item_tree[func.visibility],
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                        has_constructor: false,
-                        // in which case we don't add the invocation, just a single attribute
+                    });
-                        // macro invocation
+                }
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                ModItem::Struct(id) => {
+                    let it = &self.item_tree[id];
-                        def = Some(DefData {
-                            id: StructLoc { 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: it.kind != StructDefKind::Record,
-                        });
-                    }
-                    ModItem::Union(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 +1111,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,
+                    }
-                        },
-                    ),
                };
            }
        }
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/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 99395667d..734310458 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);
+            }
+        }
+    }
 }