8 files changed, 216 insertions, 10 deletions

diff --git a/xtask/src/codegen.rs b/xtask/src/codegen.rs
index 3ee4c1adf..adea053b6 100644
--- a/xtask/src/codegen.rs
+++ b/xtask/src/codegen.rs
@@ -9,7 +9,8 @@ mod gen_syntax;
 mod gen_parser_tests;
 mod gen_assists_docs;
 mod gen_feature_docs;
-mod gen_features;
+mod gen_lint_completions;
+mod gen_diagnostic_docs;
 
 use std::{
     fmt, mem,
@@ -21,8 +22,9 @@ use crate::{ensure_rustfmt, project_root, Result};
 
 pub use self::{
     gen_assists_docs::{generate_assists_docs, generate_assists_tests},
+    gen_diagnostic_docs::generate_diagnostic_docs,
     gen_feature_docs::generate_feature_docs,
-    gen_features::generate_features,
+    gen_lint_completions::generate_lint_completions,
     gen_parser_tests::generate_parser_tests,
     gen_syntax::generate_syntax,
 };
@@ -40,13 +42,14 @@ pub struct CodegenCmd {
 impl CodegenCmd {
     pub fn run(self) -> Result<()> {
         if self.features {
-            generate_features(Mode::Overwrite)?;
+            generate_lint_completions(Mode::Overwrite)?;
         }
         generate_syntax(Mode::Overwrite)?;
         generate_parser_tests(Mode::Overwrite)?;
         generate_assists_tests(Mode::Overwrite)?;
         generate_assists_docs(Mode::Overwrite)?;
         generate_feature_docs(Mode::Overwrite)?;
+        generate_diagnostic_docs(Mode::Overwrite)?;
         Ok(())
     }
 }
diff --git a/xtask/src/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
index ff307e2aa..d7c85ebe9 100644
--- a/xtask/src/codegen/gen_assists_docs.rs
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -1,6 +1,6 @@
 //! Generates `assists.md` documentation.
 
-use std::{fmt, fs, path::Path};
+use std::{fmt, path::Path};
 
 use crate::{
     codegen::{self, extract_comment_blocks_with_empty_lines, reformat, Location, Mode, PREAMBLE},
@@ -39,7 +39,7 @@ impl Assist {
         return Ok(res);
 
         fn collect_file(acc: &mut Vec<Assist>, path: &Path) -> Result<()> {
-            let text = fs::read_to_string(path)?;
+            let text = xshell::read_file(path)?;
             let comment_blocks = extract_comment_blocks_with_empty_lines("Assist", &text);
 
             for block in comment_blocks {
diff --git a/xtask/src/codegen/gen_diagnostic_docs.rs b/xtask/src/codegen/gen_diagnostic_docs.rs
new file mode 100644
index 000000000..00aaea5b7
--- /dev/null
+++ b/xtask/src/codegen/gen_diagnostic_docs.rs
@@ -0,0 +1,74 @@
+//! Generates `assists.md` documentation.
+
+use std::{fmt, path::PathBuf};
+
+use crate::{
+    codegen::{self, extract_comment_blocks_with_empty_lines, Location, Mode, PREAMBLE},
+    project_root, rust_files, Result,
+};
+
+pub fn generate_diagnostic_docs(mode: Mode) -> Result<()> {
+    let diagnostics = Diagnostic::collect()?;
+    let contents =
+        diagnostics.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
+    let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
+    let dst = project_root().join("docs/user/generated_diagnostic.adoc");
+    codegen::update(&dst, &contents, mode)?;
+    Ok(())
+}
+
+#[derive(Debug)]
+struct Diagnostic {
+    id: String,
+    location: Location,
+    doc: String,
+}
+
+impl Diagnostic {
+    fn collect() -> Result<Vec<Diagnostic>> {
+        let mut res = Vec::new();
+        for path in rust_files(&project_root()) {
+            collect_file(&mut res, path)?;
+        }
+        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
+        return Ok(res);
+
+        fn collect_file(acc: &mut Vec<Diagnostic>, path: PathBuf) -> Result<()> {
+            let text = xshell::read_file(&path)?;
+            let comment_blocks = extract_comment_blocks_with_empty_lines("Diagnostic", &text);
+
+            for block in comment_blocks {
+                let id = block.id;
+                if let Err(msg) = is_valid_diagnostic_name(&id) {
+                    panic!("invalid diagnostic name: {:?}:\n  {}", id, msg)
+                }
+                let doc = block.contents.join("\n");
+                let location = Location::new(path.clone(), block.line);
+                acc.push(Diagnostic { id, location, doc })
+            }
+
+            Ok(())
+        }
+    }
+}
+
+fn is_valid_diagnostic_name(diagnostic: &str) -> Result<(), String> {
+    let diagnostic = diagnostic.trim();
+    if diagnostic.find(char::is_whitespace).is_some() {
+        return Err("Diagnostic names can't contain whitespace symbols".into());
+    }
+    if diagnostic.chars().any(|c| c.is_ascii_uppercase()) {
+        return Err("Diagnostic names can't contain uppercase symbols".into());
+    }
+    if diagnostic.chars().any(|c| !c.is_ascii()) {
+        return Err("Diagnostic can't contain non-ASCII symbols".into());
+    }
+
+    Ok(())
+}
+
+impl fmt::Display for Diagnostic {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "=== {}\n**Source:** {}\n{}", self.id, self.location, self.doc)
+    }
+}
diff --git a/xtask/src/codegen/gen_feature_docs.rs b/xtask/src/codegen/gen_feature_docs.rs
index 341e67c73..065dd33f1 100644
--- a/xtask/src/codegen/gen_feature_docs.rs
+++ b/xtask/src/codegen/gen_feature_docs.rs
@@ -1,6 +1,6 @@
 //! Generates `assists.md` documentation.
 
-use std::{fmt, fs, path::PathBuf};
+use std::{fmt, path::PathBuf};
 
 use crate::{
     codegen::{self, extract_comment_blocks_with_empty_lines, Location, Mode, PREAMBLE},
@@ -33,7 +33,7 @@ impl Feature {
         return Ok(res);
 
         fn collect_file(acc: &mut Vec<Feature>, path: PathBuf) -> Result<()> {
-            let text = fs::read_to_string(&path)?;
+            let text = xshell::read_file(&path)?;
             let comment_blocks = extract_comment_blocks_with_empty_lines("Feature", &text);
 
             for block in comment_blocks {
diff --git a/xtask/src/codegen/gen_lint_completions.rs b/xtask/src/codegen/gen_lint_completions.rs
new file mode 100644
index 000000000..cffe954f8
--- /dev/null
+++ b/xtask/src/codegen/gen_lint_completions.rs
@@ -0,0 +1,113 @@
+//! Generates descriptors structure for unstable feature from Unstable Book
+use std::path::{Path, PathBuf};
+
+use quote::quote;
+use walkdir::WalkDir;
+use xshell::{cmd, read_file};
+
+use crate::{
+    codegen::{project_root, reformat, update, Mode, Result},
+    run_rustfmt,
+};
+
+pub fn generate_lint_completions(mode: Mode) -> Result<()> {
+    if !Path::new("./target/rust").exists() {
+        cmd!("git clone --depth=1 https://github.com/rust-lang/rust ./target/rust").run()?;
+    }
+
+    let ts_features = generate_descriptor("./target/rust/src/doc/unstable-book/src".into())?;
+    cmd!("curl http://rust-lang.github.io/rust-clippy/master/lints.json --output ./target/clippy_lints.json").run()?;
+
+    let ts_clippy = generate_descriptor_clippy(&Path::new("./target/clippy_lints.json"))?;
+    let ts = quote! {
+        use crate::complete_attribute::LintCompletion;
+        #ts_features
+        #ts_clippy
+    };
+    let contents = reformat(ts.to_string().as_str())?;
+
+    let destination = project_root().join("crates/completion/src/generated_lint_completions.rs");
+    update(destination.as_path(), &contents, mode)?;
+    run_rustfmt(mode)?;
+
+    Ok(())
+}
+
+fn generate_descriptor(src_dir: PathBuf) -> Result<proc_macro2::TokenStream> {
+    let definitions = ["language-features", "library-features"]
+        .iter()
+        .flat_map(|it| WalkDir::new(src_dir.join(it)))
+        .filter_map(|e| e.ok())
+        .filter(|entry| {
+            // Get all `.md ` files
+            entry.file_type().is_file() && entry.path().extension().unwrap_or_default() == "md"
+        })
+        .map(|entry| {
+            let path = entry.path();
+            let feature_ident = path.file_stem().unwrap().to_str().unwrap().replace("-", "_");
+            let doc = read_file(path).unwrap();
+
+            quote! { LintCompletion { label: #feature_ident, description: #doc } }
+        });
+
+    let ts = quote! {
+        pub(super) const FEATURES:  &[LintCompletion] = &[
+            #(#definitions),*
+        ];
+    };
+
+    Ok(ts)
+}
+
+#[derive(Default)]
+struct ClippyLint {
+    help: String,
+    id: String,
+}
+
+fn generate_descriptor_clippy(path: &Path) -> Result<proc_macro2::TokenStream> {
+    let file_content = read_file(path)?;
+    let mut clippy_lints: Vec<ClippyLint> = vec![];
+
+    for line in file_content.lines().map(|line| line.trim()) {
+        if line.starts_with(r#""id":"#) {
+            let clippy_lint = ClippyLint {
+                id: line
+                    .strip_prefix(r#""id": ""#)
+                    .expect("should be prefixed by id")
+                    .strip_suffix(r#"","#)
+                    .expect("should be suffixed by comma")
+                    .into(),
+                help: String::new(),
+            };
+            clippy_lints.push(clippy_lint)
+        } else if line.starts_with(r#""What it does":"#) {
+            // Typical line to strip: "What is doest": "Here is my useful content",
+            let prefix_to_strip = r#""What it does": ""#;
+            let suffix_to_strip = r#"","#;
+
+            let clippy_lint = clippy_lints.last_mut().expect("clippy lint must already exist");
+            clippy_lint.help = line
+                .strip_prefix(prefix_to_strip)
+                .expect("should be prefixed by what it does")
+                .strip_suffix(suffix_to_strip)
+                .expect("should be suffixed by comma")
+                .into();
+        }
+    }
+
+    let definitions = clippy_lints.into_iter().map(|clippy_lint| {
+        let lint_ident = format!("clippy::{}", clippy_lint.id);
+        let doc = clippy_lint.help;
+
+        quote! { LintCompletion { label: #lint_ident, description: #doc } }
+    });
+
+    let ts = quote! {
+        pub(super) const CLIPPY_LINTS:  &[LintCompletion] = &[
+            #(#definitions),*
+        ];
+    };
+
+    Ok(ts)
+}
diff --git a/xtask/src/codegen/gen_parser_tests.rs b/xtask/src/codegen/gen_parser_tests.rs
index 96fdd9216..19ae949d4 100644
--- a/xtask/src/codegen/gen_parser_tests.rs
+++ b/xtask/src/codegen/gen_parser_tests.rs
@@ -124,7 +124,7 @@ fn existing_tests(dir: &Path, ok: bool) -> Result<HashMap<String, (PathBuf, Test
             let file_name = path.file_name().unwrap().to_str().unwrap();
             file_name[5..file_name.len() - 3].to_string()
         };
-        let text = fs::read_to_string(&path)?;
+        let text = xshell::read_file(&path)?;
         let test = Test { name: name.clone(), text, ok };
         if let Some(old) = res.insert(name, (path, test)) {
             println!("Duplicate test: {:?}", old);
diff --git a/xtask/src/release.rs b/xtask/src/release.rs
index 14fc1f0dd..3cf0d849f 100644
--- a/xtask/src/release.rs
+++ b/xtask/src/release.rs
@@ -52,7 +52,14 @@ https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
         let path = changelog_dir.join(format!("{}-changelog-{}.adoc", today, changelog_n));
         write_file(&path, &contents)?;
 
-        for &adoc in ["manual.adoc", "generated_features.adoc", "generated_assists.adoc"].iter() {
+        for &adoc in [
+            "manual.adoc",
+            "generated_features.adoc",
+            "generated_assists.adoc",
+            "generated_diagnostic.adoc",
+        ]
+        .iter()
+        {
             let src = project_root().join("./docs/user/").join(adoc);
             let dst = website_root.join(adoc);
             cp(src, dst)?;
diff --git a/xtask/tests/tidy.rs b/xtask/tests/tidy.rs
index d335adb72..9de60c76c 100644
--- a/xtask/tests/tidy.rs
+++ b/xtask/tests/tidy.rs
@@ -42,6 +42,7 @@ fn smoke_test_docs_generation() {
     // We don't commit docs to the repo, so we can just overwrite in tests.
     codegen::generate_assists_docs(Mode::Overwrite).unwrap();
     codegen::generate_feature_docs(Mode::Overwrite).unwrap();
+    codegen::generate_diagnostic_docs(Mode::Overwrite).unwrap();
 }
 
 #[test]
@@ -130,6 +131,14 @@ https://github.blog/2015-06-08-how-to-undo-almost-anything-with-git/#redo-after-
 }
 
 fn deny_clippy(path: &PathBuf, text: &String) {
+    let ignore = &[
+        // The documentation in string literals may contain anything for its own purposes
+        "completion/src/generated_lint_completions.rs",
+    ];
+    if ignore.iter().any(|p| path.ends_with(p)) {
+        return;
+    }
+
     if text.contains("[\u{61}llow(clippy") {
         panic!(
             "\n\nallowing lints is forbidden: {}.
@@ -213,7 +222,7 @@ fn check_todo(path: &Path, text: &str) {
         // `ast::make`.
         "ast/make.rs",
         // The documentation in string literals may contain anything for its own purposes
-        "completion/generated_features.rs",
+        "completion/src/generated_lint_completions.rs",
     ];
     if need_todo.iter().any(|p| path.ends_with(p)) {
         return;