4 files changed, 368 insertions, 7 deletions

diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index 107bd8432..6ae7c9e6c 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -38,3 +38,4 @@ hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
 expect-test = "1.1"
+cov-mark = "1.1.0"
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index fe32f39b6..22697a537 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -6,6 +6,7 @@
 
 mod fixes;
 mod field_shorthand;
+mod unlinked_file;
 
 use std::cell::RefCell;
 
@@ -22,6 +23,7 @@ use syntax::{
     SyntaxNode, SyntaxNodePtr, TextRange,
 };
 use text_edit::TextEdit;
+use unlinked_file::UnlinkedFile;
 
 use crate::{FileId, Label, SourceChange};
 
@@ -156,6 +158,18 @@ pub(crate) fn diagnostics(
                 .with_code(Some(d.code())),
             );
         })
+        .on::<UnlinkedFile, _>(|d| {
+            // Override severity and mark as unused.
+            res.borrow_mut().push(
+                Diagnostic::hint(
+                    sema.diagnostics_display_range(d.display_source()).range,
+                    d.message(),
+                )
+                .with_unused(true)
+                .with_fix(d.fix(&sema))
+                .with_code(Some(d.code())),
+            );
+        })
         .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
             // Use more accurate position if available.
             let display_range = d
@@ -197,9 +211,13 @@ pub(crate) fn diagnostics(
             );
         });
 
-    if let Some(m) = sema.to_module_def(file_id) {
-        m.diagnostics(db, &mut sink);
-    };
+    match sema.to_module_def(file_id) {
+        Some(m) => m.diagnostics(db, &mut sink),
+        None => {
+            sink.push(UnlinkedFile { file_id, node: SyntaxNodePtr::new(&parse.tree().syntax()) });
+        }
+    }
+
     drop(sink);
     res.into_inner()
 }
@@ -307,6 +325,17 @@ mod tests {
         );
     }
 
+    /// Checks that there's a diagnostic *without* fix at `$0`.
+    fn check_no_fix(ra_fixture: &str) {
+        let (analysis, file_position) = fixture::position(ra_fixture);
+        let diagnostic = analysis
+            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .unwrap()
+            .pop()
+            .unwrap();
+        assert!(diagnostic.fix.is_none(), "got a fix when none was expected: {:?}", diagnostic);
+    }
+
     /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
     /// apply to the file containing the cursor.
     pub(crate) fn check_no_diagnostics(ra_fixture: &str) {
@@ -975,4 +1004,132 @@ impl TestStruct {
 
         check_fix(input, expected);
     }
+
+    #[test]
+    fn unlinked_file_prepend_first_item() {
+        cov_mark::check!(unlinked_file_prepend_before_first_item);
+        check_fix(
+            r#"
+//- /main.rs
+fn f() {}
+//- /foo.rs
+$0
+"#,
+            r#"
+mod foo;
+
+fn f() {}
+"#,
+        );
+    }
+
+    #[test]
+    fn unlinked_file_append_mod() {
+        cov_mark::check!(unlinked_file_append_to_existing_mods);
+        check_fix(
+            r#"
+//- /main.rs
+//! Comment on top
+
+mod preexisting;
+
+mod preexisting2;
+
+struct S;
+
+mod preexisting_bottom;)
+//- /foo.rs
+$0
+"#,
+            r#"
+//! Comment on top
+
+mod preexisting;
+
+mod preexisting2;
+mod foo;
+
+struct S;
+
+mod preexisting_bottom;)
+"#,
+        );
+    }
+
+    #[test]
+    fn unlinked_file_insert_in_empty_file() {
+        cov_mark::check!(unlinked_file_empty_file);
+        check_fix(
+            r#"
+//- /main.rs
+//- /foo.rs
+$0
+"#,
+            r#"
+mod foo;
+"#,
+        );
+    }
+
+    #[test]
+    fn unlinked_file_old_style_modrs() {
+        check_fix(
+            r#"
+//- /main.rs
+mod submod;
+//- /submod/mod.rs
+// in mod.rs
+//- /submod/foo.rs
+$0
+"#,
+            r#"
+// in mod.rs
+mod foo;
+"#,
+        );
+    }
+
+    #[test]
+    fn unlinked_file_new_style_mod() {
+        check_fix(
+            r#"
+//- /main.rs
+mod submod;
+//- /submod.rs
+//- /submod/foo.rs
+$0
+"#,
+            r#"
+mod foo;
+"#,
+        );
+    }
+
+    #[test]
+    fn unlinked_file_with_cfg_off() {
+        cov_mark::check!(unlinked_file_skip_fix_when_mod_already_exists);
+        check_no_fix(
+            r#"
+//- /main.rs
+#[cfg(never)]
+mod foo;
+
+//- /foo.rs
+$0
+"#,
+        );
+    }
+
+    #[test]
+    fn unlinked_file_with_cfg_on() {
+        check_no_diagnostics(
+            r#"
+//- /main.rs
+#[cfg(not(never))]
+mod foo;
+
+//- /foo.rs
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
new file mode 100644
index 000000000..c5741bf6b
--- /dev/null
+++ b/crates/ide/src/diagnostics/unlinked_file.rs
@@ -0,0 +1,156 @@
+//! Diagnostic emitted for files that aren't part of any crate.
+
+use hir::{
+    db::DefDatabase,
+    diagnostics::{Diagnostic, DiagnosticCode},
+    InFile,
+};
+use ide_db::{
+    base_db::{FileId, FileLoader, SourceDatabase, SourceDatabaseExt},
+    source_change::SourceChange,
+    RootDatabase,
+};
+use syntax::{
+    ast::{self, ModuleItemOwner, NameOwner},
+    AstNode, SyntaxNodePtr,
+};
+use text_edit::TextEdit;
+
+use crate::Fix;
+
+use super::fixes::DiagnosticWithFix;
+
+#[derive(Debug)]
+pub(crate) struct UnlinkedFile {
+    pub(crate) file_id: FileId,
+    pub(crate) node: SyntaxNodePtr,
+}
+
+impl Diagnostic for UnlinkedFile {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unlinked-file")
+    }
+
+    fn message(&self) -> String {
+        "file not included in module tree".to_string()
+    }
+
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file_id.into(), self.node.clone())
+    }
+
+    fn as_any(&self) -> &(dyn std::any::Any + Send + 'static) {
+        self
+    }
+}
+
+impl DiagnosticWithFix for UnlinkedFile {
+    fn fix(&self, sema: &hir::Semantics<RootDatabase>) -> Option<Fix> {
+        // If there's an existing module that could add a `mod` item to include the unlinked file,
+        // suggest that as a fix.
+
+        let source_root = sema.db.source_root(sema.db.file_source_root(self.file_id));
+        let our_path = source_root.path_for_file(&self.file_id)?;
+        let module_name = our_path.name_and_extension()?.0;
+
+        // Candidates to look for:
+        // - `mod.rs` in the same folder
+        //   - we also check `main.rs` and `lib.rs`
+        // - `$dir.rs` in the parent folder, where `$dir` is the directory containing `self.file_id`
+        let parent = our_path.parent()?;
+        let mut paths =
+            vec![parent.join("mod.rs")?, parent.join("main.rs")?, parent.join("lib.rs")?];
+
+        // `submod/bla.rs` -> `submod.rs`
+        if let Some(newmod) = (|| {
+            let name = parent.name_and_extension()?.0;
+            parent.parent()?.join(&format!("{}.rs", name))
+        })() {
+            paths.push(newmod);
+        }
+
+        for path in &paths {
+            if let Some(parent_id) = source_root.file_for_path(path) {
+                for krate in sema.db.relevant_crates(*parent_id).iter() {
+                    let crate_def_map = sema.db.crate_def_map(*krate);
+                    for (_, module) in crate_def_map.modules() {
+                        if module.origin.is_inline() {
+                            // We don't handle inline `mod parent {}`s, they use different paths.
+                            continue;
+                        }
+
+                        if module.origin.file_id() == Some(*parent_id) {
+                            return make_fix(sema.db, *parent_id, module_name, self.file_id);
+                        }
+                    }
+                }
+            }
+        }
+
+        None
+    }
+}
+
+fn make_fix(
+    db: &RootDatabase,
+    parent_file_id: FileId,
+    new_mod_name: &str,
+    added_file_id: FileId,
+) -> Option<Fix> {
+    fn is_outline_mod(item: &ast::Item) -> bool {
+        matches!(item, ast::Item::Module(m) if m.item_list().is_none())
+    }
+
+    let mod_decl = format!("mod {};", new_mod_name);
+    let ast: ast::SourceFile = db.parse(parent_file_id).tree();
+
+    let mut builder = TextEdit::builder();
+
+    // If there's an existing `mod m;` statement matching the new one, don't emit a fix (it's
+    // probably `#[cfg]`d out).
+    for item in ast.items() {
+        if let ast::Item::Module(m) = item {
+            if let Some(name) = m.name() {
+                if m.item_list().is_none() && name.to_string() == new_mod_name {
+                    cov_mark::hit!(unlinked_file_skip_fix_when_mod_already_exists);
+                    return None;
+                }
+            }
+        }
+    }
+
+    // If there are existing `mod m;` items, append after them (after the first group of them, rather).
+    match ast
+        .items()
+        .skip_while(|item| !is_outline_mod(item))
+        .take_while(|item| is_outline_mod(item))
+        .last()
+    {
+        Some(last) => {
+            cov_mark::hit!(unlinked_file_append_to_existing_mods);
+            builder.insert(last.syntax().text_range().end(), format!("\n{}", mod_decl));
+        }
+        None => {
+            // Prepend before the first item in the file.
+            match ast.items().next() {
+                Some(item) => {
+                    cov_mark::hit!(unlinked_file_prepend_before_first_item);
+                    builder.insert(item.syntax().text_range().start(), format!("{}\n\n", mod_decl));
+                }
+                None => {
+                    // No items in the file, so just append at the end.
+                    cov_mark::hit!(unlinked_file_empty_file);
+                    builder.insert(ast.syntax().text_range().end(), format!("{}\n", mod_decl));
+                }
+            }
+        }
+    }
+
+    let edit = builder.finish();
+    let trigger_range = db.parse(added_file_id).tree().syntax().text_range();
+    Some(Fix::new(
+        &format!("Insert `{}`", mod_decl),
+        SourceChange::from_text_edit(parent_file_id, edit),
+        trigger_range,
+    ))
+}
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index faa91541e..27d35de5b 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -2,7 +2,7 @@ use std::fmt;
 
 use ast::NameOwner;
 use cfg::CfgExpr;
-use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
+use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics};
 use ide_assists::utils::test_related_attribute;
 use ide_db::{
     base_db::{FilePosition, FileRange},
@@ -340,11 +340,21 @@ fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Op
             // FIXME: this also looks very wrong
             if let Some(assoc_def) = assoc_def {
                 if let hir::AssocItemContainer::Impl(imp) = assoc_def.container(sema.db) {
-                    if let Some(adt) = imp.target_ty(sema.db).as_adt() {
-                        let name = adt.name(sema.db).to_string();
+                    let ty = imp.target_ty(sema.db);
+                    if let Some(adt) = ty.as_adt() {
+                        let name = adt.name(sema.db);
                         let idx = path.rfind(':').map_or(0, |idx| idx + 1);
                         let (prefix, suffix) = path.split_at(idx);
-                        return format!("{}{}::{}", prefix, name, suffix);
+                        let mut ty_params = ty.type_parameters().peekable();
+                        let params = if ty_params.peek().is_some() {
+                            format!(
+                                "<{}>",
+                                ty_params.format_with(", ", |ty, cb| cb(&ty.display(sema.db)))
+                            )
+                        } else {
+                            String::new()
+                        };
+                        return format!("{}{}{}::{}", prefix, name, params, suffix);
                     }
                 }
             }
@@ -1406,4 +1416,41 @@ mod tests {
             "#]],
         );
     }
+
+    #[test]
+    fn doc_test_type_params() {
+        check(
+            r#"
+//- /lib.rs
+$0
+struct Foo<T, U>;
+
+impl<T, U> Foo<T, U> {
+    /// ```rust
+    /// ````
+    fn t() {}
+}
+"#,
+            &[&DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 47..85,
+                            name: "t",
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "Foo<T, U>::t",
+                            ),
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
 }