From 6983091d6d255bcfd17c4f8c14015d8abc77928d Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Mon, 30 Jul 2018 14:06:22 +0300 Subject: Cleanup tools --- tools/src/bin/collect-tests.rs | 133 ----------------------------- tools/src/bin/gen.rs | 121 --------------------------- tools/src/bin/main.rs | 184 +++++++++++++++++++++++++++++++++++++++++ tools/src/bin/parse.rs | 19 ----- 4 files changed, 184 insertions(+), 273 deletions(-) delete mode 100644 tools/src/bin/collect-tests.rs delete mode 100644 tools/src/bin/gen.rs create mode 100644 tools/src/bin/main.rs delete mode 100644 tools/src/bin/parse.rs (limited to 'tools/src/bin') diff --git a/tools/src/bin/collect-tests.rs b/tools/src/bin/collect-tests.rs deleted file mode 100644 index a52e7b119..000000000 --- a/tools/src/bin/collect-tests.rs +++ /dev/null @@ -1,133 +0,0 @@ -extern crate file; -extern crate itertools; -extern crate walkdir; - -use walkdir::WalkDir; -use itertools::Itertools; - -use std::path::{Path, PathBuf}; -use std::collections::HashSet; -use std::fs; - -fn main() { - let verify = ::std::env::args().any(|arg| arg == "--verify"); - - let d = grammar_dir(); - let tests = tests_from_dir(&d); - let existing = existing_tests(); - - for t in existing.difference(&tests) { - panic!("Test is deleted: {}\n{}", t.name, t.text); - } - - let new_tests = tests.difference(&existing); - for (i, t) in new_tests.enumerate() { - if verify { - panic!("Inline test is not recorded: {}", t.name); - } - - let name = format!("{:04}_{}.rs", existing.len() + i + 1, t.name); - println!("Creating {}", name); - let path = inline_tests_dir().join(name); - file::put_text(&path, &t.text).unwrap(); - } -} - -#[derive(Debug, Eq)] -struct Test { - name: String, - text: String, -} - -impl PartialEq for Test { - fn eq(&self, other: &Test) -> bool { - self.name.eq(&other.name) - } -} - -impl ::std::hash::Hash for Test { - fn hash(&self, state: &mut H) { - self.name.hash(state) - } -} - -fn tests_from_dir(dir: &Path) -> HashSet { - let mut res = HashSet::new(); - for entry in WalkDir::new(dir) { - let entry = entry.unwrap(); - if !entry.file_type().is_file() { - continue; - } - if entry.path().extension().unwrap_or_default() != "rs" { - continue; - } - let text = file::get_text(entry.path()).unwrap(); - - for test in collect_tests(&text) { - if let Some(old_test) = res.replace(test) { - panic!("Duplicate test: {}", old_test.name) - } - } - } - res -} - -fn collect_tests(s: &str) -> Vec { - let mut res = vec![]; - let prefix = "// "; - let comment_blocks = s.lines() - .map(str::trim_left) - .group_by(|line| line.starts_with(prefix)); - - 'outer: for (is_comment, block) in comment_blocks.into_iter() { - if !is_comment { - continue; - } - let mut block = block.map(|line| &line[prefix.len()..]); - - let name = loop { - match block.next() { - Some(line) if line.starts_with("test ") => break line["test ".len()..].to_string(), - Some(_) => (), - None => continue 'outer, - } - }; - let text: String = itertools::join(block.chain(::std::iter::once("")), "\n"); - assert!(!text.trim().is_empty() && text.ends_with("\n")); - res.push(Test { name, text }) - } - res -} - -fn existing_tests() -> HashSet { - let mut res = HashSet::new(); - for file in fs::read_dir(&inline_tests_dir()).unwrap() { - let file = file.unwrap(); - let path = file.path(); - if path.extension().unwrap_or_default() != "rs" { - continue; - } - let name = path.file_name().unwrap().to_str().unwrap(); - let name = name["0000_".len()..name.len() - 3].to_string(); - let text = file::get_text(&path).unwrap(); - res.insert(Test { name, text }); - } - res -} - -fn inline_tests_dir() -> PathBuf { - let res = base_dir().join("tests/data/parser/inline"); - if !res.is_dir() { - fs::create_dir_all(&res).unwrap(); - } - res -} - -fn grammar_dir() -> PathBuf { - base_dir().join("src/parser/grammar") -} - -fn base_dir() -> PathBuf { - let dir = env!("CARGO_MANIFEST_DIR"); - PathBuf::from(dir).parent().unwrap().to_owned() -} diff --git a/tools/src/bin/gen.rs b/tools/src/bin/gen.rs deleted file mode 100644 index 2d3cd422d..000000000 --- a/tools/src/bin/gen.rs +++ /dev/null @@ -1,121 +0,0 @@ -extern crate serde; -#[macro_use] -extern crate serde_derive; - -extern crate file; -extern crate ron; - -use std::path::PathBuf; -use std::fmt::Write; - -fn main() { - let grammar = Grammar::read(); - let text = grammar.to_syntax_kinds(); - let target = generated_file(); - if text != file::get_text(&target).unwrap_or_default() { - file::put_text(&target, &text).unwrap(); - } -} - -#[derive(Deserialize)] -struct Grammar { - keywords: Vec, - contextual_keywords: Vec, - tokens: Vec, - nodes: Vec, -} - -impl Grammar { - fn read() -> Grammar { - let text = file::get_text(&grammar_file()).unwrap(); - ron::de::from_str(&text).unwrap() - } - - fn to_syntax_kinds(&self) -> String { - let mut acc = String::new(); - acc.push_str("#![allow(bad_style, missing_docs, unreachable_pub)]\n"); - acc.push_str("#![cfg_attr(rustfmt, rustfmt_skip)]\n"); - acc.push_str("//! Generated from grammar.ron\n"); - acc.push_str("use super::SyntaxInfo;\n"); - acc.push_str("\n"); - - let syntax_kinds: Vec = self.tokens - .iter() - .cloned() - .chain(self.keywords.iter().map(|kw| kw_token(kw))) - .chain(self.contextual_keywords.iter().map(|kw| kw_token(kw))) - .chain(self.nodes.iter().cloned()) - .collect(); - - // enum SyntaxKind - acc.push_str("/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`.\n"); - acc.push_str("#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\n"); - acc.push_str("pub enum SyntaxKind {\n"); - for kind in syntax_kinds.iter() { - write!(acc, " {},\n", scream(kind)).unwrap(); - } - acc.push_str("\n"); - acc.push_str(" // Technical SyntaxKinds: they appear temporally during parsing,\n"); - acc.push_str(" // but never end up in the final tree\n"); - acc.push_str(" #[doc(hidden)]\n"); - acc.push_str(" TOMBSTONE,\n"); - acc.push_str(" #[doc(hidden)]\n"); - acc.push_str(" EOF,\n"); - acc.push_str("}\n"); - acc.push_str("pub(crate) use self::SyntaxKind::*;\n"); - acc.push_str("\n"); - - // fn info - acc.push_str("impl SyntaxKind {\n"); - acc.push_str(" pub(crate) fn info(self) -> &'static SyntaxInfo {\n"); - acc.push_str(" match self {\n"); - for kind in syntax_kinds.iter() { - let sname = scream(kind); - write!( - acc, - " {sname} => &SyntaxInfo {{ name: \"{sname}\" }},\n", - sname = sname - ).unwrap(); - } - acc.push_str("\n"); - acc.push_str(" TOMBSTONE => &SyntaxInfo { name: \"TOMBSTONE\" },\n"); - acc.push_str(" EOF => &SyntaxInfo { name: \"EOF\" },\n"); - acc.push_str(" }\n"); - acc.push_str(" }\n"); - - // fn from_keyword - acc.push_str(" pub(crate) fn from_keyword(ident: &str) -> Option {\n"); - acc.push_str(" match ident {\n"); - // NB: no contextual_keywords here! - for kw in self.keywords.iter() { - write!(acc, " {:?} => Some({}),\n", kw, kw_token(kw)).unwrap(); - } - acc.push_str(" _ => None,\n"); - acc.push_str(" }\n"); - acc.push_str(" }\n"); - acc.push_str("}\n"); - acc.push_str("\n"); - acc - } -} - -fn grammar_file() -> PathBuf { - base_dir().join("src/grammar.ron") -} - -fn generated_file() -> PathBuf { - base_dir().join("src/syntax_kinds/generated.rs") -} - -fn scream(word: &str) -> String { - word.chars().map(|c| c.to_ascii_uppercase()).collect() -} - -fn kw_token(keyword: &str) -> String { - format!("{}_KW", scream(keyword)) -} - -fn base_dir() -> PathBuf { - let dir = env!("CARGO_MANIFEST_DIR"); - PathBuf::from(dir).parent().unwrap().to_owned() -} diff --git a/tools/src/bin/main.rs b/tools/src/bin/main.rs new file mode 100644 index 000000000..6a9793fff --- /dev/null +++ b/tools/src/bin/main.rs @@ -0,0 +1,184 @@ +extern crate clap; +#[macro_use] +extern crate failure; +extern crate tera; +extern crate ron; +extern crate walkdir; +extern crate itertools; + +use std::{ + fs, + path::{Path}, + collections::HashSet, +}; +use clap::{App, Arg, SubCommand}; +use itertools::Itertools; + +type Result = ::std::result::Result; + +const GRAMMAR_DIR: &str = "./src/parser/grammar"; +const INLINE_TESTS_DIR: &str = "tests/data/parser/inline"; +const GRAMMAR: &str = "./src/grammar.ron"; +const SYNTAX_KINDS: &str = "./src/syntax_kinds/generated.rs"; +const SYNTAX_KINDS_TEMPLATE: &str = "./src/syntax_kinds/generated.rs.tera"; + +fn main() -> Result<()> { + let matches = App::new("tasks") + .setting(clap::AppSettings::SubcommandRequiredElseHelp) + .arg( + Arg::with_name("verify") + .long("--verify") + .help("Verify that generated code is up-to-date") + .global(true) + ) + .subcommand(SubCommand::with_name("gen-kinds")) + .subcommand(SubCommand::with_name("gen-tests")) + .get_matches(); + match matches.subcommand() { + (name, Some(matches)) => run_gen_command(name, matches.is_present("verify"))?, + _ => unreachable!(), + } + Ok(()) +} + +fn run_gen_command(name: &str, verify: bool) -> Result<()> { + match name { + "gen-kinds" => update(Path::new(SYNTAX_KINDS), &get_kinds()?, verify), + "gen-tests" => gen_tests(verify), + _ => unreachable!(), + } +} + +fn update(path: &Path, contents: &str, verify: bool) -> Result<()> { + match fs::read_to_string(path) { + Ok(ref old_contents) if old_contents == contents => { + return Ok(()); + } + _ => (), + } + if verify { + bail!("`{}` is not up-to-date", path.display()); + } + fs::write(path, contents)?; + Ok(()) +} + +fn get_kinds() -> Result { + let grammar = grammar()?; + let template = fs::read_to_string(SYNTAX_KINDS_TEMPLATE)?; + let ret = tera::Tera::one_off(&template, &grammar, false).map_err(|e| { + format_err!("template error: {}", e) + })?; + Ok(ret) +} + +fn grammar() -> Result { + let text = fs::read_to_string(GRAMMAR)?; + let ret = ron::de::from_str(&text)?; + Ok(ret) +} + +fn gen_tests(verify: bool) -> Result<()> { + let tests = tests_from_dir(Path::new(GRAMMAR_DIR))?; + + let inline_tests_dir = Path::new(INLINE_TESTS_DIR); + if !inline_tests_dir.is_dir() { + fs::create_dir_all(inline_tests_dir)?; + } + let existing = existing_tests(inline_tests_dir)?; + + for t in existing.difference(&tests) { + panic!("Test is deleted: {}\n{}", t.name, t.text); + } + + let new_tests = tests.difference(&existing); + for (i, t) in new_tests.enumerate() { + let name = format!("{:04}_{}.rs", existing.len() + i + 1, t.name); + let path = inline_tests_dir.join(name); + update(&path, &t.text, verify)?; + } + Ok(()) +} + +#[derive(Debug, Eq)] +struct Test { + name: String, + text: String, +} + +impl PartialEq for Test { + fn eq(&self, other: &Test) -> bool { + self.name.eq(&other.name) + } +} + +impl ::std::hash::Hash for Test { + fn hash(&self, state: &mut H) { + self.name.hash(state) + } +} + +fn tests_from_dir(dir: &Path) -> Result> { + let mut res = HashSet::new(); + for entry in ::walkdir::WalkDir::new(dir) { + let entry = entry.unwrap(); + if !entry.file_type().is_file() { + continue; + } + if entry.path().extension().unwrap_or_default() != "rs" { + continue; + } + let text = fs::read_to_string(entry.path())?; + + for test in collect_tests(&text) { + if let Some(old_test) = res.replace(test) { + bail!("Duplicate test: {}", old_test.name) + } + } + } + Ok(res) +} + +fn collect_tests(s: &str) -> Vec { + let mut res = vec![]; + let prefix = "// "; + let comment_blocks = s.lines() + .map(str::trim_left) + .group_by(|line| line.starts_with(prefix)); + + 'outer: for (is_comment, block) in comment_blocks.into_iter() { + if !is_comment { + continue; + } + let mut block = block.map(|line| &line[prefix.len()..]); + + let name = loop { + match block.next() { + Some(line) if line.starts_with("test ") => break line["test ".len()..].to_string(), + Some(_) => (), + None => continue 'outer, + } + }; + let text: String = itertools::join(block.chain(::std::iter::once("")), "\n"); + assert!(!text.trim().is_empty() && text.ends_with("\n")); + res.push(Test { name, text }) + } + res +} + +fn existing_tests(dir: &Path) -> Result> { + let mut res = HashSet::new(); + for file in fs::read_dir(dir)? { + let file = file?; + let path = file.path(); + if path.extension().unwrap_or_default() != "rs" { + continue; + } + let name = path.file_name().unwrap().to_str().unwrap(); + let name = name["0000_".len()..name.len() - 3].to_string(); + let text = fs::read_to_string(&path)?; + res.insert(Test { name, text }); + } + Ok(res) +} + diff --git a/tools/src/bin/parse.rs b/tools/src/bin/parse.rs deleted file mode 100644 index cb3414711..000000000 --- a/tools/src/bin/parse.rs +++ /dev/null @@ -1,19 +0,0 @@ -extern crate libsyntax2; - -use std::io::Read; - -use libsyntax2::{parse}; -use libsyntax2::utils::dump_tree_green; - -fn main() { - let text = read_input(); - let file = parse(text); - let tree = dump_tree_green(&file); - println!("{}", tree); -} - -fn read_input() -> String { - let mut buff = String::new(); - ::std::io::stdin().read_to_string(&mut buff).unwrap(); - buff -} -- cgit v1.2.3