From 8cefdb5527d011d7d5ca2902791b7c3da0276fec Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 18 Aug 2019 23:11:08 +0300 Subject: use quote! macro to generate grammar We already use syn"e elsewhere (transitively), so it make sense to cut down on the number of technologies and get rid of tera --- Cargo.lock | 1 + crates/ra_syntax/src/grammar.ron | 54 ++++++------- crates/ra_tools/Cargo.toml | 1 + crates/ra_tools/src/codegen.rs | 165 ++++++++++++++++++++++++++++++++++++--- 4 files changed, 181 insertions(+), 40 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e7354e937..530764c37 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1362,6 +1362,7 @@ name = "ra_tools" version = "0.1.0" dependencies = [ "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)", + "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", "ron 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron index a18810253..26efeeba9 100644 --- a/crates/ra_syntax/src/grammar.ron +++ b/crates/ra_syntax/src/grammar.ron @@ -263,7 +263,7 @@ Grammar( "SourceFile": ( traits: [ "ModuleItemOwner", "FnDefOwner" ], collections: [ - ["modules", "Module"], + ("modules", "Module"), ] ), "FnDef": ( @@ -286,7 +286,7 @@ Grammar( "DocCommentsOwner" ] ), - "NamedFieldDefList": (collections: [["fields", "NamedFieldDef"]]), + "NamedFieldDefList": (collections: [("fields", "NamedFieldDef")]), "NamedFieldDef": ( traits: [ "VisibilityOwner", @@ -296,7 +296,7 @@ Grammar( "TypeAscriptionOwner" ] ), - "PosFieldDefList": (collections: [["fields", "PosFieldDef"]]), + "PosFieldDefList": (collections: [("fields", "PosFieldDef")]), "PosFieldDef": ( traits: ["VisibilityOwner", "AttrsOwner"], options: ["TypeRef"]), "EnumDef": ( traits: [ "VisibilityOwner", @@ -305,7 +305,7 @@ Grammar( "AttrsOwner", "DocCommentsOwner" ], options: [["variant_list", "EnumVariantList"]] ), - "EnumVariantList": ( collections: [["variants", "EnumVariant"]] ), + "EnumVariantList": ( collections: [("variants", "EnumVariant")] ), "EnumVariant": ( traits: ["NameOwner", "DocCommentsOwner", "AttrsOwner"], options: ["Expr"] ), "TraitDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner", "TypeBoundsOwner"], @@ -316,7 +316,7 @@ Grammar( options: [ "ItemList" ] ), "ItemList": ( - collections: [["impl_items", "ImplItem"]], + collections: [("impl_items", "ImplItem")], traits: [ "FnDefOwner", "ModuleItemOwner" ], ), "ConstDef": ( @@ -355,7 +355,7 @@ Grammar( "ImplBlock": (options: ["ItemList"], traits: ["TypeParamsOwner", "AttrsOwner"]), "ParenType": (options: ["TypeRef"]), - "TupleType": ( collections: [["fields", "TypeRef"]] ), + "TupleType": ( collections: [("fields", "TypeRef")] ), "NeverType": (), "PathType": (options: ["Path"]), "PointerType": (options: ["TypeRef"]), @@ -405,10 +405,10 @@ Grammar( ), "TupleExpr": ( - collections: [["exprs", "Expr"]] + collections: [("exprs", "Expr")] ), "ArrayExpr": ( - collections: [["exprs", "Expr"]] + collections: [("exprs", "Expr")] ), "ParenExpr": (options: ["Expr"]), "PathExpr": (options: ["Path"]), @@ -449,7 +449,7 @@ Grammar( options: [ "Expr", "MatchArmList" ], ), "MatchArmList": ( - collections: [ ["arms", "MatchArm"] ], + collections: [ ("arms", "MatchArm") ], traits: [ "AttrsOwner" ] ), "MatchArm": ( @@ -457,13 +457,13 @@ Grammar( [ "guard", "MatchGuard" ], "Expr", ], - collections: [ [ "pats", "Pat" ] ], + collections: [ ("pats", "Pat") ], traits: [ "AttrsOwner" ] ), "MatchGuard": (options: ["Expr"]), "StructLit": (options: ["Path", "NamedFieldList"]), "NamedFieldList": ( - collections: [ ["fields", "NamedField"] ], + collections: [ ("fields", "NamedField") ], options: [["spread", "Expr"]] ), "NamedField": (options: ["NameRef", "Expr"]), @@ -532,8 +532,8 @@ Grammar( "StructPat": ( options: ["FieldPatList", "Path"] ), "FieldPatList": ( collections: [ - ["field_pats", "FieldPat"], - ["bind_pats", "BindPat"], + ("field_pats", "FieldPat"), + ("bind_pats", "BindPat"), ] ), "FieldPat": ( @@ -542,9 +542,9 @@ Grammar( ), "TupleStructPat": ( options: ["Path"], - collections: [["args", "Pat"]], + collections: [("args", "Pat")], ), - "TuplePat": ( collections: [["args", "Pat"]] ), + "TuplePat": ( collections: [("args", "Pat")] ), "SlicePat": (), "RangePat": (), "LiteralPat": (options: ["Literal"]), @@ -575,8 +575,8 @@ Grammar( "TokenTree": (), "TypeParamList": ( collections: [ - ["type_params", "TypeParam" ], - ["lifetime_params", "LifetimeParam" ], + ("type_params", "TypeParam" ), + ("lifetime_params", "LifetimeParam" ), ] ), "TypeParam": ( traits: ["NameOwner", "AttrsOwner", "TypeBoundsOwner", "DefaultTypeParamOwner"] ), @@ -590,7 +590,7 @@ Grammar( ), "TypeBoundList": ( collections: [ - ["bounds", "TypeBound"], + ("bounds", "TypeBound"), ] ), "WherePred": ( @@ -603,7 +603,7 @@ Grammar( ), "WhereClause": ( collections: [ - ["predicates", "WherePred"], + ("predicates", "WherePred"), ], ), "ExprStmt": ( @@ -627,7 +627,7 @@ Grammar( "Block": ( options: [ "Expr" ], collections: [ - ["statements", "Stmt"], + ("statements", "Stmt"), ], traits: [ "AttrsOwner", @@ -636,7 +636,7 @@ Grammar( "ParamList": ( options: [ "SelfParam" ], collections: [ - ["params", "Param"] + ("params", "Param"), ] ), "SelfParam": ( @@ -663,14 +663,14 @@ Grammar( traits: ["NameOwner"], ), "UseTreeList": ( - collections: [["use_trees", "UseTree"]] + collections: [("use_trees", "UseTree")] ), "ExternCrateItem": ( options: ["NameRef", "Alias"], ), "ArgList": ( collections: [ - ["args", "Expr"] + ("args", "Expr"), ] ), "Path": ( @@ -683,9 +683,9 @@ Grammar( options: [ "NameRef", "TypeArgList" ] ), "TypeArgList": (collections: [ - ["type_args", "TypeArg"], - ["lifetime_args", "LifetimeArg"], - ["assoc_type_args", "AssocTypeArg"], + ("type_args", "TypeArg"), + ("lifetime_args", "LifetimeArg"), + ("assoc_type_args", "AssocTypeArg"), ]), "TypeArg": (options: ["TypeRef"]), "AssocTypeArg": (options: ["NameRef", "TypeRef"]), @@ -698,7 +698,7 @@ Grammar( "MacroStmts" : ( options: [ "Expr" ], collections: [ - ["statements", "Stmt"], + ("statements", "Stmt"), ], ) }, diff --git a/crates/ra_tools/Cargo.toml b/crates/ra_tools/Cargo.toml index ab9fa5d86..1bb6fb71c 100644 --- a/crates/ra_tools/Cargo.toml +++ b/crates/ra_tools/Cargo.toml @@ -12,4 +12,5 @@ itertools = "0.8.0" clap = "2.32.0" quote = "1.0.2" ron = "0.5.1" +heck = "0.3.0" serde = { version = "1.0.0", features = ["derive"] } diff --git a/crates/ra_tools/src/codegen.rs b/crates/ra_tools/src/codegen.rs index f0a54808a..e14092704 100644 --- a/crates/ra_tools/src/codegen.rs +++ b/crates/ra_tools/src/codegen.rs @@ -1,27 +1,162 @@ -use std::{collections::BTreeMap, fs, path::Path}; +use std::{ + collections::BTreeMap, + fs, + io::Write, + path::Path, + process::{Command, Stdio}, +}; -use quote::quote; +use heck::{ShoutySnakeCase, SnakeCase}; +use quote::{format_ident, quote}; use ron; use serde::Deserialize; -use crate::{project_root, Mode, Result, AST, GRAMMAR}; +use crate::{project_root, Mode, Result, AST, GRAMMAR, SYNTAX_KINDS}; 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); - generate_ast(&grammar, &ast, mode) -} - -fn generate_ast(grammar_src: &Path, dst: &Path, mode: Mode) -> Result<()> { - let src: Grammar = { - let text = fs::read_to_string(grammar_src)?; + let grammar: Grammar = { + let text = fs::read_to_string(grammar)?; ron::de::from_str(&text)? }; - eprintln!("{:#?}", src); + + let _syntax_kinds = project_root().join(SYNTAX_KINDS); + let _ast = project_root().join(AST); + + let ast = generate_ast(&grammar)?; + println!("{}", ast); Ok(()) } +fn generate_ast(grammar: &Grammar) -> Result { + let nodes = grammar.ast.iter().map(|(name, ast_node)| { + let variants = + ast_node.variants.iter().map(|var| format_ident!("{}", var)).collect::>(); + 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::>(); + + 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 { + 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 reformat(text: impl std::fmt::Display) -> Result { + 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)?; + Ok(stdout) +} + #[derive(Deserialize, Debug)] struct Grammar { single_byte_tokens: Vec<(String, String)>, @@ -35,10 +170,14 @@ struct Grammar { #[derive(Deserialize, Debug)] struct AstNode { + #[serde(default)] + #[serde(rename = "enum")] + variants: Vec, + #[serde(default)] traits: Vec, #[serde(default)] - collections: Vec, + collections: Vec<(String, String)>, #[serde(default)] options: Vec, } -- cgit v1.2.3