6 files changed, 92 insertions, 12 deletions

diff --git a/xtask/src/codegen/gen_lint_completions.rs b/xtask/src/codegen/gen_lint_completions.rs
index 3b54b2489..54fcaa0e6 100644
--- a/xtask/src/codegen/gen_lint_completions.rs
+++ b/xtask/src/codegen/gen_lint_completions.rs
@@ -28,7 +28,7 @@ pub(crate) fn generate_lint_completions() -> Result<()> {
     contents.push('\n');
 
     cmd!("curl https://rust-lang.github.io/rust-clippy/master/lints.json --output ./target/clippy_lints.json").run()?;
-    generate_descriptor_clippy(&mut contents, &Path::new("./target/clippy_lints.json"))?;
+    generate_descriptor_clippy(&mut contents, Path::new("./target/clippy_lints.json"))?;
     let contents = reformat(&contents)?;
 
     let destination = project_root().join("crates/ide_db/src/helpers/generated_lints.rs");
@@ -140,8 +140,7 @@ fn generate_descriptor_clippy(buf: &mut String, path: &Path) -> Result<()> {
                 .expect("should be prefixed by what it does")
                 .strip_suffix(suffix_to_strip)
                 .map(unescape)
-                .expect("should be suffixed by comma")
-                .into();
+                .expect("should be suffixed by comma");
         }
     }
     clippy_lints.sort_by(|lint, lint2| lint.id.cmp(&lint2.id));
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index b0b9e30db..5435da76e 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -258,7 +258,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
     for chunk in ast.split("# [pretty_doc_comment_placeholder_workaround] ") {
         res.push_str(chunk);
         if let Some(doc) = docs.next() {
-            write_doc_comment(&doc, &mut res);
+            write_doc_comment(doc, &mut res);
         }
     }
 
@@ -294,14 +294,14 @@ fn generate_syntax_kinds(grammar: KindsSrc<'_>) -> Result<String> {
 
     let full_keywords_values = &grammar.keywords;
     let full_keywords =
-        full_keywords_values.iter().map(|kw| format_ident!("{}_KW", to_upper_snake_case(&kw)));
+        full_keywords_values.iter().map(|kw| format_ident!("{}_KW", to_upper_snake_case(kw)));
 
     let all_keywords_values =
         grammar.keywords.iter().chain(grammar.contextual_keywords.iter()).collect::<Vec<_>>();
     let all_keywords_idents = all_keywords_values.iter().map(|kw| format_ident!("{}", kw));
     let all_keywords = all_keywords_values
         .iter()
-        .map(|name| format_ident!("{}_KW", to_upper_snake_case(&name)))
+        .map(|name| format_ident!("{}_KW", to_upper_snake_case(name)))
         .collect::<Vec<_>>();
 
     let literals =
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 3a67294c5..c7363688a 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -45,8 +45,8 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
     patch
         .replace(r#""version": "0.4.0-dev""#, &format!(r#""version": "{}""#, version))
         .replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag))
-        .replace(r#""$generated-start": false,"#, "")
-        .replace(",\n                \"$generated-end\": false", "");
+        .replace(r#""$generated-start": {},"#, "")
+        .replace(",\n                \"$generated-end\": {}", "");
 
     if nightly {
         patch.replace(
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index d0bef7b7a..063e11a5a 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -1,4 +1,4 @@
-//! See https://github.com/matklad/cargo-xtask/.
+//! See <https://github.com/matklad/cargo-xtask/>.
 //!
 //! This binary defines various auxiliary build commands, which are not
 //! expressible with just `cargo`. Notably, it provides tests via `cargo test -p xtask`
diff --git a/xtask/src/metrics.rs b/xtask/src/metrics.rs
index 34679062f..7b190d425 100644
--- a/xtask/src/metrics.rs
+++ b/xtask/src/metrics.rs
@@ -71,7 +71,7 @@ impl Metrics {
         Ok(())
     }
     fn measure_analysis_stats_self(&mut self) -> Result<()> {
-        self.measure_analysis_stats_path("self", &".")
+        self.measure_analysis_stats_path("self", ".")
     }
     fn measure_analysis_stats(&mut self, bench: &str) -> Result<()> {
         self.measure_analysis_stats_path(
diff --git a/xtask/src/tidy.rs b/xtask/src/tidy.rs
index 9447d463d..06219d155 100644
--- a/xtask/src/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -1,4 +1,7 @@
-use std::path::{Path, PathBuf};
+use std::{
+    collections::HashSet,
+    path::{Path, PathBuf},
+};
 
 use xshell::{cmd, pushd, pushenv, read_file};
 
@@ -81,15 +84,19 @@ Please adjust docs/dev/lsp-extensions.md.
 #[test]
 fn rust_files_are_tidy() {
     let mut tidy_docs = TidyDocs::default();
+    let mut tidy_marks = TidyMarks::default();
     for path in rust_files() {
         let text = read_file(&path).unwrap();
         check_todo(&path, &text);
         check_dbg(&path, &text);
+        check_test_attrs(&path, &text);
         check_trailing_ws(&path, &text);
         deny_clippy(&path, &text);
         tidy_docs.visit(&path, &text);
+        tidy_marks.visit(&path, &text);
     }
     tidy_docs.finish();
+    tidy_marks.finish();
 }
 
 #[test]
@@ -328,6 +335,36 @@ fn check_dbg(path: &Path, text: &str) {
     }
 }
 
+fn check_test_attrs(path: &Path, text: &str) {
+    let ignore_rule =
+        "https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/dev/style.md#ignore";
+    let need_ignore: &[&str] = &[
+        // Special case to run `#[ignore]` tests
+        "ide/src/runnables.rs",
+        // A legit test which needs to be ignored, as it takes too long to run
+        // :(
+        "hir_def/src/nameres/collector.rs",
+        // Obviously needs ignore.
+        "ide_assists/src/handlers/toggle_ignore.rs",
+        // See above.
+        "ide_assists/src/tests/generated.rs",
+    ];
+    if text.contains("#[ignore") && !need_ignore.iter().any(|p| path.ends_with(p)) {
+        panic!("\ndon't `#[ignore]` tests, see:\n\n    {}\n\n   {}\n", ignore_rule, path.display(),)
+    }
+
+    let panic_rule =
+        "https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/dev/style.md#should_panic";
+    let need_panic: &[&str] = &["test_utils/src/fixture.rs"];
+    if text.contains("#[should_panic") && !need_panic.iter().any(|p| path.ends_with(p)) {
+        panic!(
+            "\ndon't add `#[should_panic]` tests, see:\n\n    {}\n\n   {}\n",
+            panic_rule,
+            path.display(),
+        )
+    }
+}
+
 fn check_trailing_ws(path: &Path, text: &str) {
     if is_exclude_dir(path, &["test_data"]) {
         return;
@@ -366,7 +403,10 @@ impl TidyDocs {
                 self.contains_fixme.push(path.to_path_buf());
             }
         } else {
-            if text.contains("// Feature:") || text.contains("// Assist:") {
+            if text.contains("// Feature:")
+                || text.contains("// Assist:")
+                || text.contains("// Diagnostic:")
+            {
                 return;
             }
             self.missing_docs.push(path.display().to_string());
@@ -408,6 +448,39 @@ fn is_exclude_dir(p: &Path, dirs_to_exclude: &[&str]) -> bool {
         .any(|it| dirs_to_exclude.contains(&it))
 }
 
+#[derive(Default)]
+struct TidyMarks {
+    hits: HashSet<String>,
+    checks: HashSet<String>,
+}
+
+impl TidyMarks {
+    fn visit(&mut self, _path: &Path, text: &str) {
+        for line in text.lines() {
+            if let Some(mark) = find_mark(line, "hit") {
+                self.hits.insert(mark.to_string());
+            }
+            if let Some(mark) = find_mark(line, "check") {
+                self.checks.insert(mark.to_string());
+            }
+            if let Some(mark) = find_mark(line, "check_count") {
+                self.checks.insert(mark.to_string());
+            }
+        }
+    }
+
+    fn finish(self) {
+        assert!(!self.hits.is_empty());
+
+        let diff: Vec<_> =
+            self.hits.symmetric_difference(&self.checks).map(|it| it.as_str()).collect();
+
+        if !diff.is_empty() {
+            panic!("unpaired marks: {:?}", diff)
+        }
+    }
+}
+
 #[allow(deprecated)]
 fn stable_hash(text: &str) -> u64 {
     use std::hash::{Hash, Hasher, SipHasher};
@@ -417,3 +490,11 @@ fn stable_hash(text: &str) -> u64 {
     text.hash(&mut hasher);
     hasher.finish()
 }
+
+fn find_mark<'a>(text: &'a str, mark: &'static str) -> Option<&'a str> {
+    let idx = text.find(mark)?;
+    let text = text[idx + mark.len()..].strip_prefix("!(")?;
+    let idx = text.find(|c: char| !(c.is_alphanumeric() || c == '_'))?;
+    let text = &text[..idx];
+    Some(text)
+}