3 files changed, 165 insertions, 68 deletions

diff --git a/xtask/src/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
new file mode 100644
index 000000000..05afda8f1
--- /dev/null
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -0,0 +1,137 @@
+use std::{fs, path::Path};
+
+use crate::{
+    codegen::{self, extract_comment_blocks_with_empty_lines, Mode},
+    project_root, Result,
+};
+
+pub fn generate_assists_docs(mode: Mode) -> Result<()> {
+    let assists = collect_assists()?;
+    generate_tests(&assists, mode)?;
+    generate_docs(&assists, mode)?;
+    Ok(())
+}
+
+#[derive(Debug)]
+struct Assist {
+    id: String,
+    doc: String,
+    before: String,
+    after: String,
+}
+
+fn collect_assists() -> Result<Vec<Assist>> {
+    let mut res = Vec::new();
+    for entry in fs::read_dir(project_root().join(codegen::ASSISTS_DIR))? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_file() {
+            collect_file(&mut res, path.as_path())?;
+        }
+    }
+    res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
+    return Ok(res);
+
+    fn collect_file(acc: &mut Vec<Assist>, path: &Path) -> Result<()> {
+        let text = fs::read_to_string(path)?;
+        let comment_blocks = extract_comment_blocks_with_empty_lines(&text);
+
+        for block in comment_blocks {
+            // FIXME: doesn't support blank lines yet, need to tweak
+            // `extract_comment_blocks` for that.
+            let mut lines = block.iter();
+            let first_line = lines.next().unwrap();
+            if !first_line.starts_with("Assist: ") {
+                continue;
+            }
+            let id = first_line["Assist: ".len()..].to_string();
+            assert!(
+                id.chars().all(|it| it.is_ascii_lowercase() || it == '_'),
+                "invalid assist id: {:?}",
+                id
+            );
+
+            let doc = take_until(lines.by_ref(), "```").trim().to_string();
+            assert!(
+                doc.chars().next().unwrap().is_ascii_uppercase() && doc.ends_with('.'),
+                "\n\n{}: assist docs should be proper sentences, with capitalization and a full stop at the end.\n\n{}\n\n",
+                id, doc,
+            );
+
+            let before = take_until(lines.by_ref(), "```");
+
+            assert_eq!(lines.next().unwrap().as_str(), "->");
+            assert_eq!(lines.next().unwrap().as_str(), "```");
+            let after = take_until(lines.by_ref(), "```");
+            acc.push(Assist { id, doc, before, after })
+        }
+
+        fn take_until<'a>(lines: impl Iterator<Item = &'a String>, marker: &str) -> String {
+            let mut buf = Vec::new();
+            for line in lines {
+                if line == marker {
+                    break;
+                }
+                buf.push(line.clone());
+            }
+            buf.join("\n")
+        }
+        Ok(())
+    }
+}
+
+fn generate_tests(assists: &[Assist], mode: Mode) -> Result<()> {
+    let mut buf = String::from("use super::check;\n");
+
+    for assist in assists.iter() {
+        let test = format!(
+            r######"
+#[test]
+fn doctest_{}() {{
+    check(
+        "{}",
+r#####"
+{}
+"#####, r#####"
+{}
+"#####)
+}}
+"######,
+            assist.id, assist.id, assist.before, assist.after
+        );
+
+        buf.push_str(&test)
+    }
+    let buf = codegen::reformat(buf)?;
+    codegen::update(&project_root().join(codegen::ASSISTS_TESTS), &buf, mode)
+}
+
+fn generate_docs(assists: &[Assist], mode: Mode) -> Result<()> {
+    let mut buf = String::from(
+        "# Assists\n\nCursor position or selection is signified by `┃` character.\n\n",
+    );
+
+    for assist in assists {
+        let before = assist.before.replace("<|>", "┃"); // Unicode pseudo-graphics bar
+        let after = assist.after.replace("<|>", "┃");
+        let docs = format!(
+            "
+## `{}`
+
+{}
+
+```rust
+// BEFORE
+{}
+
+// AFTER
+{}
+```
+",
+            assist.id, assist.doc, before, after
+        );
+        buf.push_str(&docs);
+    }
+
+    codegen::update(&project_root().join(codegen::ASSISTS_DOCS), &buf, mode)
+}
diff --git a/xtask/src/codegen/gen_parser_tests.rs b/xtask/src/codegen/gen_parser_tests.rs
index 0f550d948..d0f0f683b 100644
--- a/xtask/src/codegen/gen_parser_tests.rs
+++ b/xtask/src/codegen/gen_parser_tests.rs
@@ -3,12 +3,12 @@
 
 use std::{
     collections::HashMap,
-    fs,
+    fs, iter,
     path::{Path, PathBuf},
 };
 
 use crate::{
-    codegen::{self, update, Mode},
+    codegen::{self, extract_comment_blocks, update, Mode},
     project_root, Result,
 };
 
@@ -56,48 +56,29 @@ struct Tests {
     pub err: HashMap<String, Test>,
 }
 
-fn collect_tests(s: &str) -> Vec<(usize, Test)> {
-    let mut res = vec![];
-    let prefix = "// ";
-    let lines = s.lines().map(str::trim_start).enumerate();
-
-    let mut block = vec![];
-    for (line_idx, line) in lines {
-        let is_comment = line.starts_with(prefix);
-        if is_comment {
-            block.push((line_idx, &line[prefix.len()..]));
+fn collect_tests(s: &str) -> Vec<Test> {
+    let mut res = Vec::new();
+    for comment_block in extract_comment_blocks(s) {
+        let first_line = &comment_block[0];
+        let (name, ok) = if first_line.starts_with("test ") {
+            let name = first_line["test ".len()..].to_string();
+            (name, true)
+        } else if first_line.starts_with("test_err ") {
+            let name = first_line["test_err ".len()..].to_string();
+            (name, false)
         } else {
-            process_block(&mut res, &block);
-            block.clear();
-        }
-    }
-    process_block(&mut res, &block);
-    return res;
-
-    fn process_block(acc: &mut Vec<(usize, Test)>, block: &[(usize, &str)]) {
-        if block.is_empty() {
-            return;
-        }
-        let mut ok = true;
-        let mut block = block.iter();
-        let (start_line, name) = loop {
-            match block.next() {
-                Some(&(idx, line)) if line.starts_with("test ") => {
-                    break (idx, line["test ".len()..].to_string());
-                }
-                Some(&(idx, line)) if line.starts_with("test_err ") => {
-                    ok = false;
-                    break (idx, line["test_err ".len()..].to_string());
-                }
-                Some(_) => (),
-                None => return,
-            }
+            continue;
         };
-        let text: String =
-            block.map(|(_, line)| *line).chain(std::iter::once("")).collect::<Vec<_>>().join("\n");
+        let text: String = comment_block[1..]
+            .iter()
+            .cloned()
+            .chain(iter::once(String::new()))
+            .collect::<Vec<_>>()
+            .join("\n");
         assert!(!text.trim().is_empty() && text.ends_with('\n'));
-        acc.push((start_line, Test { name, text, ok }))
+        res.push(Test { name, text, ok })
     }
+    res
 }
 
 fn tests_from_dir(dir: &Path) -> Result<Tests> {
@@ -118,15 +99,13 @@ fn tests_from_dir(dir: &Path) -> Result<Tests> {
     fn process_file(res: &mut Tests, path: &Path) -> Result<()> {
         let text = fs::read_to_string(path)?;
 
-        for (_, test) in collect_tests(&text) {
+        for test in collect_tests(&text) {
             if test.ok {
                 if let Some(old_test) = res.ok.insert(test.name.clone(), test) {
-                    Err(format!("Duplicate test: {}", old_test.name))?
-                }
-            } else {
-                if let Some(old_test) = res.err.insert(test.name.clone(), test) {
-                    Err(format!("Duplicate test: {}", old_test.name))?
+                    return Err(format!("Duplicate test: {}", old_test.name).into());
                 }
+            } else if let Some(old_test) = res.err.insert(test.name.clone(), test) {
+                return Err(format!("Duplicate test: {}", old_test.name).into());
             }
         }
         Ok(())
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index 6a81c0e4d..88f2ac0e3 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -3,12 +3,7 @@
 //! Specifically, it generates the `SyntaxKind` enum and a number of newtype
 //! wrappers around `SyntaxNode` which implement `ra_syntax::AstNode`.
 
-use std::{
-    collections::BTreeMap,
-    fs,
-    io::Write,
-    process::{Command, Stdio},
-};
+use std::{collections::BTreeMap, fs};
 
 use proc_macro2::{Punct, Spacing};
 use quote::{format_ident, quote};
@@ -163,7 +158,7 @@ fn generate_ast(grammar: &Grammar) -> Result<String> {
         #(#nodes)*
     };
 
-    let pretty = reformat(ast)?;
+    let pretty = codegen::reformat(ast)?;
     Ok(pretty)
 }
 
@@ -276,21 +271,7 @@ fn generate_syntax_kinds(grammar: &Grammar) -> Result<String> {
         }
     };
 
-    reformat(ast)
-}
-
-fn reformat(text: impl std::fmt::Display) -> Result<String> {
-    let mut rustfmt = Command::new("rustfmt")
-        .arg("--config-path")
-        .arg(project_root().join("rustfmt.toml"))
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .spawn()?;
-    write!(rustfmt.stdin.take().unwrap(), "{}", text)?;
-    let output = rustfmt.wait_with_output()?;
-    let stdout = String::from_utf8(output.stdout)?;
-    let preamble = "Generated file, do not edit by hand, see `crate/ra_tools/src/codegen`";
-    Ok(format!("//! {}\n\n{}", preamble, stdout))
+    codegen::reformat(ast)
 }
 
 #[derive(Deserialize, Debug)]