Merge #1697

1697: Use quote instead of tera for boilerplate generation r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

5 files changed, 382 insertions, 19 deletions

diff --git a/crates/ra_tools/Cargo.toml b/crates/ra_tools/Cargo.toml
index 9c5430992..4c9aa1cc3 100644
--- a/crates/ra_tools/Cargo.toml
+++ b/crates/ra_tools/Cargo.toml
@@ -6,7 +6,11 @@ authors = ["rust-analyzer developers"]
 publish = false
 
 [dependencies]
-teraron = "0.1.0"
 walkdir = "2.1.3"
 itertools = "0.8.0"
 clap = "2.32.0"
+quote = "1.0.2"
+proc-macro2 = "1.0.1"
+ron = "0.5.1"
+heck = "0.3.0"
+serde = { version = "1.0.0", features = ["derive"] }
diff --git a/crates/ra_tools/src/boilerplate_gen.rs b/crates/ra_tools/src/boilerplate_gen.rs
new file mode 100644
index 000000000..7ef51e82a
--- /dev/null
+++ b/crates/ra_tools/src/boilerplate_gen.rs
@@ -0,0 +1,342 @@
+use std::{
+    collections::BTreeMap,
+    fs,
+    io::Write,
+    process::{Command, Stdio},
+};
+
+use heck::{ShoutySnakeCase, SnakeCase};
+use proc_macro2::{Punct, Spacing};
+use quote::{format_ident, quote};
+use ron;
+use serde::Deserialize;
+
+use crate::{project_root, update, Mode, Result, AST, GRAMMAR, SYNTAX_KINDS};
+
+pub fn generate_boilerplate(mode: Mode) -> Result<()> {
+    let grammar = project_root().join(GRAMMAR);
+    let grammar: Grammar = {
+        let text = fs::read_to_string(grammar)?;
+        ron::de::from_str(&text)?
+    };
+
+    let syntax_kinds_file = project_root().join(SYNTAX_KINDS);
+    let syntax_kinds = generate_syntax_kinds(&grammar)?;
+    update(syntax_kinds_file.as_path(), &syntax_kinds, mode)?;
+
+    let ast_file = project_root().join(AST);
+    let ast = generate_ast(&grammar)?;
+    update(ast_file.as_path(), &ast, mode)?;
+
+    Ok(())
+}
+
+fn generate_ast(grammar: &Grammar) -> Result<String> {
+    let nodes = grammar.ast.iter().map(|(name, ast_node)| {
+        let variants =
+            ast_node.variants.iter().map(|var| format_ident!("{}", var)).collect::<Vec<_>>();
+        let name = format_ident!("{}", name);
+
+        let kinds = if variants.is_empty() { vec![name.clone()] } else { variants.clone() }
+            .into_iter()
+            .map(|name| format_ident!("{}", name.to_string().to_shouty_snake_case()))
+            .collect::<Vec<_>>();
+
+        let variants = if variants.is_empty() {
+            None
+        } else {
+            let kind_enum = format_ident!("{}Kind", name);
+            Some(quote!(
+                pub enum #kind_enum {
+                    #(#variants(#variants),)*
+                }
+
+                #(
+                impl From<#variants> for #name {
+                    fn from(node: #variants) -> #name {
+                        #name { syntax: node.syntax }
+                    }
+                }
+                )*
+
+                impl #name {
+                    pub fn kind(&self) -> #kind_enum {
+                        let syntax = self.syntax.clone();
+                        match syntax.kind() {
+                            #(
+                            #kinds =>
+                                #kind_enum::#variants(#variants { syntax }),
+                            )*
+                            _ => unreachable!(),
+                        }
+                    }
+                }
+            ))
+        };
+
+        let traits = ast_node.traits.iter().map(|trait_name| {
+            let trait_name = format_ident!("{}", trait_name);
+            quote!(impl ast::#trait_name for #name {})
+        });
+
+        let collections = ast_node.collections.iter().map(|(name, kind)| {
+            let method_name = format_ident!("{}", name);
+            let kind = format_ident!("{}", kind);
+            quote! {
+                pub fn #method_name(&self) -> AstChildren<#kind> {
+                    AstChildren::new(&self.syntax)
+                }
+            }
+        });
+
+        let options = ast_node.options.iter().map(|attr| {
+            let method_name = match attr {
+                Attr::Type(t) => format_ident!("{}", t.to_snake_case()),
+                Attr::NameType(n, _) => format_ident!("{}", n),
+            };
+            let ty = match attr {
+                Attr::Type(t) | Attr::NameType(_, t) => format_ident!("{}", t),
+            };
+            quote! {
+                pub fn #method_name(&self) -> Option<#ty> {
+                    AstChildren::new(&self.syntax).next()
+                }
+            }
+        });
+
+        quote! {
+            #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+            pub struct #name {
+                pub(crate) syntax: SyntaxNode,
+            }
+
+            impl AstNode for #name {
+                fn can_cast(kind: SyntaxKind) -> bool {
+                    match kind {
+                        #(#kinds)|* => true,
+                        _ => false,
+                    }
+                }
+                fn cast(syntax: SyntaxNode) -> Option<Self> {
+                    if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
+                }
+                fn syntax(&self) -> &SyntaxNode { &self.syntax }
+            }
+
+            #variants
+
+            #(#traits)*
+
+            impl #name {
+                #(#collections)*
+                #(#options)*
+            }
+        }
+    });
+
+    let ast = quote! {
+        use crate::{
+            SyntaxNode, SyntaxKind::{self, *},
+            ast::{self, AstNode, AstChildren},
+        };
+
+        #(#nodes)*
+    };
+
+    let pretty = reformat(ast)?;
+    Ok(pretty)
+}
+
+fn generate_syntax_kinds(grammar: &Grammar) -> Result<String> {
+    let single_byte_tokens_values =
+        grammar.single_byte_tokens.iter().map(|(token, _name)| token.chars().next().unwrap());
+    let single_byte_tokens = grammar
+        .single_byte_tokens
+        .iter()
+        .map(|(_token, name)| format_ident!("{}", name))
+        .collect::<Vec<_>>();
+
+    let punctuation_values =
+        grammar.single_byte_tokens.iter().chain(grammar.multi_byte_tokens.iter()).map(
+            |(token, _name)| {
+                if "{}[]()".contains(token) {
+                    let c = token.chars().next().unwrap();
+                    quote! { #c }
+                } else {
+                    let cs = token.chars().map(|c| Punct::new(c, Spacing::Joint));
+                    quote! { #(#cs)* }
+                }
+            },
+        );
+    let punctuation = single_byte_tokens
+        .clone()
+        .into_iter()
+        .chain(grammar.multi_byte_tokens.iter().map(|(_token, name)| format_ident!("{}", name)))
+        .collect::<Vec<_>>();
+
+    let full_keywords_values = &grammar.keywords;
+    let full_keywords =
+        full_keywords_values.iter().map(|kw| format_ident!("{}_KW", kw.to_shouty_snake_case()));
+
+    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", name.to_shouty_snake_case()))
+        .collect::<Vec<_>>();
+
+    let literals =
+        grammar.literals.iter().map(|name| format_ident!("{}", name)).collect::<Vec<_>>();
+
+    let tokens = grammar.tokens.iter().map(|name| format_ident!("{}", name)).collect::<Vec<_>>();
+
+    let nodes = grammar.nodes.iter().map(|name| format_ident!("{}", name)).collect::<Vec<_>>();
+
+    let ast = quote! {
+        #![allow(bad_style, missing_docs, unreachable_pub)]
+        use super::SyntaxInfo;
+
+        /// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`.
+        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        #[repr(u16)]
+        pub enum SyntaxKind {
+            // Technical SyntaxKinds: they appear temporally during parsing,
+            // but never end up in the final tree
+            #[doc(hidden)]
+            TOMBSTONE,
+            #[doc(hidden)]
+            EOF,
+            #(#punctuation,)*
+            #(#all_keywords,)*
+            #(#literals,)*
+            #(#tokens,)*
+            #(#nodes,)*
+
+            // Technical kind so that we can cast from u16 safely
+            #[doc(hidden)]
+            __LAST,
+        }
+        use self::SyntaxKind::*;
+
+        impl From<u16> for SyntaxKind {
+            fn from(d: u16) -> SyntaxKind {
+                assert!(d <= (__LAST as u16));
+                unsafe { std::mem::transmute::<u16, SyntaxKind>(d) }
+            }
+        }
+
+        impl From<SyntaxKind> for u16 {
+            fn from(k: SyntaxKind) -> u16 {
+                k as u16
+            }
+        }
+
+        impl SyntaxKind {
+            pub fn is_keyword(self) -> bool {
+                match self {
+                    #(#all_keywords)|* => true,
+                    _ => false,
+                }
+            }
+
+            pub fn is_punct(self) -> bool {
+                match self {
+                    #(#punctuation)|* => true,
+                    _ => false,
+                }
+            }
+
+            pub fn is_literal(self) -> bool {
+                match self {
+                    #(#literals)|* => true,
+                    _ => false,
+                }
+            }
+
+            pub(crate) fn info(self) -> &'static SyntaxInfo {
+                match self {
+                    #(#punctuation => &SyntaxInfo { name: stringify!(#punctuation) },)*
+                    #(#all_keywords => &SyntaxInfo { name: stringify!(#all_keywords) },)*
+                    #(#literals => &SyntaxInfo { name: stringify!(#literals) },)*
+                    #(#tokens => &SyntaxInfo { name: stringify!(#tokens) },)*
+                    #(#nodes => &SyntaxInfo { name: stringify!(#nodes) },)*
+                    TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
+                    EOF => &SyntaxInfo { name: "EOF" },
+                    __LAST => &SyntaxInfo { name: "__LAST" },
+                }
+            }
+
+            pub fn from_keyword(ident: &str) -> Option<SyntaxKind> {
+                let kw = match ident {
+                    #(#full_keywords_values => #full_keywords,)*
+                    _ => return None,
+                };
+                Some(kw)
+            }
+
+            pub fn from_char(c: char) -> Option<SyntaxKind> {
+                let tok = match c {
+                    #(#single_byte_tokens_values => #single_byte_tokens,)*
+                    _ => return None,
+                };
+                Some(tok)
+            }
+        }
+
+        #[macro_export]
+        macro_rules! T {
+            #((#punctuation_values) => { $crate::SyntaxKind::#punctuation };)*
+            #((#all_keywords_idents) => { $crate::SyntaxKind::#all_keywords };)*
+        }
+    };
+
+    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))
+}
+
+#[derive(Deserialize, Debug)]
+struct Grammar {
+    single_byte_tokens: Vec<(String, String)>,
+    multi_byte_tokens: Vec<(String, String)>,
+    keywords: Vec<String>,
+    contextual_keywords: Vec<String>,
+    literals: Vec<String>,
+    tokens: Vec<String>,
+    nodes: Vec<String>,
+    ast: BTreeMap<String, AstNode>,
+}
+
+#[derive(Deserialize, Debug)]
+struct AstNode {
+    #[serde(default)]
+    #[serde(rename = "enum")]
+    variants: Vec<String>,
+
+    #[serde(default)]
+    traits: Vec<String>,
+    #[serde(default)]
+    collections: Vec<(String, String)>,
+    #[serde(default)]
+    options: Vec<Attr>,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(untagged)]
+enum Attr {
+    Type(String),
+    NameType(String, String),
+}
diff --git a/crates/ra_tools/src/lib.rs b/crates/ra_tools/src/lib.rs
index bb7845f7d..d47660369 100644
--- a/crates/ra_tools/src/lib.rs
+++ b/crates/ra_tools/src/lib.rs
@@ -1,3 +1,5 @@
+mod boilerplate_gen;
+
 use std::{
     collections::HashMap,
     error::Error,
@@ -9,7 +11,7 @@ use std::{
 
 use itertools::Itertools;
 
-pub use teraron::{Mode, Overwrite, Verify};
+pub use self::boilerplate_gen::generate_boilerplate;
 
 pub type Result<T> = std::result::Result<T, Box<dyn Error>>;
 
@@ -18,10 +20,17 @@ const GRAMMAR_DIR: &str = "crates/ra_parser/src/grammar";
 const OK_INLINE_TESTS_DIR: &str = "crates/ra_syntax/test_data/parser/inline/ok";
 const ERR_INLINE_TESTS_DIR: &str = "crates/ra_syntax/test_data/parser/inline/err";
 
-pub const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs.tera";
-pub const AST: &str = "crates/ra_syntax/src/ast/generated.rs.tera";
+pub const SYNTAX_KINDS: &str = "crates/ra_parser/src/syntax_kind/generated.rs";
+pub const AST: &str = "crates/ra_syntax/src/ast/generated.rs";
 const TOOLCHAIN: &str = "stable";
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Mode {
+    Overwrite,
+    Verify,
+}
+pub use Mode::*;
+
 #[derive(Debug)]
 pub struct Test {
     pub name: String,
@@ -66,15 +75,6 @@ pub fn collect_tests(s: &str) -> Vec<(usize, Test)> {
     res
 }
 
-pub fn generate(mode: Mode) -> Result<()> {
-    let grammar = project_root().join(GRAMMAR);
-    let syntax_kinds = project_root().join(SYNTAX_KINDS);
-    let ast = project_root().join(AST);
-    teraron::generate(&syntax_kinds, &grammar, mode)?;
-    teraron::generate(&ast, &grammar, mode)?;
-    Ok(())
-}
-
 pub fn project_root() -> PathBuf {
     Path::new(&env!("CARGO_MANIFEST_DIR")).ancestors().nth(2).unwrap().to_path_buf()
 }
@@ -227,7 +227,7 @@ pub fn gen_tests(mode: Mode) -> Result<()> {
                     tests_dir.join(file_name)
                 }
             };
-            teraron::update(&path, &test.text, mode)?;
+            update(&path, &test.text, mode)?;
         }
         Ok(())
     }
@@ -311,3 +311,20 @@ fn existing_tests(dir: &Path, ok: bool) -> Result<HashMap<String, (PathBuf, Test
     }
     Ok(res)
 }
+
+/// A helper to update file on disk if it has changed.
+/// With verify = false,
+pub fn update(path: &Path, contents: &str, mode: Mode) -> Result<()> {
+    match fs::read_to_string(path) {
+        Ok(ref old_contents) if old_contents == contents => {
+            return Ok(());
+        }
+        _ => (),
+    }
+    if mode == Verify {
+        Err(format!("`{}` is not up-to-date", path.display()))?;
+    }
+    eprintln!("updating {}", path.display());
+    fs::write(path, contents)?;
+    Ok(())
+}
diff --git a/crates/ra_tools/src/main.rs b/crates/ra_tools/src/main.rs
index 54d96e446..03cb9d5a7 100644
--- a/crates/ra_tools/src/main.rs
+++ b/crates/ra_tools/src/main.rs
@@ -1,8 +1,8 @@
 use clap::{App, Arg, SubCommand};
 use core::str;
 use ra_tools::{
-    gen_tests, generate, install_format_hook, run, run_clippy, run_fuzzer, run_rustfmt, Cmd,
-    Overwrite, Result,
+    gen_tests, generate_boilerplate, install_format_hook, run, run_clippy, run_fuzzer, run_rustfmt,
+    Cmd, Overwrite, Result,
 };
 use std::{env, path::PathBuf};
 
@@ -49,7 +49,7 @@ fn main() -> Result<()> {
             install(opts)?
         }
         ("gen-tests", _) => gen_tests(Overwrite)?,
-        ("gen-syntax", _) => generate(Overwrite)?,
+        ("gen-syntax", _) => generate_boilerplate(Overwrite)?,
         ("format", _) => run_rustfmt(Overwrite)?,
         ("format-hook", _) => install_format_hook()?,
         ("lint", _) => run_clippy()?,
diff --git a/crates/ra_tools/tests/cli.rs b/crates/ra_tools/tests/cli.rs
index ae0eb337d..c672e5788 100644
--- a/crates/ra_tools/tests/cli.rs
+++ b/crates/ra_tools/tests/cli.rs
@@ -1,10 +1,10 @@
 use walkdir::WalkDir;
 
-use ra_tools::{gen_tests, generate, project_root, run_rustfmt, Verify};
+use ra_tools::{gen_tests, generate_boilerplate, project_root, run_rustfmt, Verify};
 
 #[test]
 fn generated_grammar_is_fresh() {
-    if let Err(error) = generate(Verify) {
+    if let Err(error) = generate_boilerplate(Verify) {
         panic!("{}. Please update it by running `cargo gen-syntax`", error);
     }
 }