git.delta.rocks / jrsonnet / refs/commits / 9b1cb43cbd7b

difftreelog

fix(fmt) differentiate between nodes of the same type

qkluvrtkYaroslav Bolyukin2026-02-08parent: #0c7230b.patch.diff
in: master

4 files changed

addedcrates/jrsonnet-formatter/src/snapshots/jrsonnet_formatter__tests__asserts.snapdiffbeforeafterboth
--- /dev/null
+++ b/crates/jrsonnet-formatter/src/snapshots/jrsonnet_formatter__tests__asserts.snap
@@ -0,0 +1,9 @@
+---
+source: crates/jrsonnet-formatter/src/tests.rs
+expression: "reformat(indoc!(\"\n\t\t\t{\n\t\t\t\tassert 1 > 0 : 'one should be greater than zero',\n\t\t\t\tassert true,\n\t\t\t\tvalue: 42,\n\t\t\t}\n\t\t\"))"
+---
+{
+	assert 1 > 0: 'one should be greater than zero',
+	assert true,
+	value: 42,
+}
modifiedcrates/jrsonnet-formatter/src/tests.rsdiffbeforeafterboth
--- a/crates/jrsonnet-formatter/src/tests.rs
+++ b/crates/jrsonnet-formatter/src/tests.rs
@@ -91,3 +91,16 @@
 		"
 	)));
 }
+
+#[test]
+fn asserts() {
+	insta::assert_snapshot!(reformat(indoc!(
+		"
+			{
+				assert 1 > 0 : 'one should be greater than zero',
+				assert true,
+				value: 42,
+			}
+		"
+	)));
+}
modifiedcrates/jrsonnet-rowan-parser/src/generated/nodes.rsdiffbeforeafterboth
--- a/crates/jrsonnet-rowan-parser/src/generated/nodes.rs
+++ b/crates/jrsonnet-rowan-parser/src/generated/nodes.rs
@@ -14,7 +14,7 @@
 }
 impl SourceFile {
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -27,7 +27,7 @@
 		support::children(&self.syntax)
 	}
 	pub fn expr_base(&self) -> Option<ExprBase> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn suffixs(&self) -> AstChildren<Suffix> {
 		support::children(&self.syntax)
@@ -46,7 +46,7 @@
 		support::token(&self.syntax, T![.])
 	}
 	pub fn index(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -75,7 +75,7 @@
 		support::token(&self.syntax, T!['['])
 	}
 	pub fn index(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![']'])
@@ -88,7 +88,7 @@
 }
 impl SuffixSlice {
 	pub fn slice_desc(&self) -> Option<SliceDesc> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -101,16 +101,16 @@
 		support::token(&self.syntax, T!['['])
 	}
 	pub fn from(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn colon_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![:])
 	}
 	pub fn end(&self) -> Option<SliceDescEnd> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn step(&self) -> Option<SliceDescStep> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![']'])
@@ -123,7 +123,7 @@
 }
 impl SuffixApply {
 	pub fn args_desc(&self) -> Option<ArgsDesc> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![tailstrict])
@@ -168,7 +168,7 @@
 }
 impl StmtAssert {
 	pub fn assertion(&self) -> Option<Assertion> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn semi_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![;])
@@ -184,13 +184,13 @@
 		support::token(&self.syntax, T![assert])
 	}
 	pub fn condition(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn colon_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![:])
 	}
 	pub fn message(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).nth(1usize)
 	}
 }
 
@@ -200,13 +200,13 @@
 }
 impl ExprBinary {
 	pub fn lhs(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn binary_operator(&self) -> Option<BinaryOperator> {
 		support::token_child(&self.syntax)
 	}
 	pub fn rhs(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).nth(1usize)
 	}
 }
 
@@ -219,7 +219,7 @@
 		support::token_child(&self.syntax)
 	}
 	pub fn rhs(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -229,7 +229,7 @@
 }
 impl ExprObjExtend {
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -242,7 +242,7 @@
 		support::token(&self.syntax, T!['('])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![')'])
@@ -301,7 +301,7 @@
 }
 impl ExprObject {
 	pub fn obj_body(&self) -> Option<ObjBody> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -314,7 +314,7 @@
 		support::token(&self.syntax, T!['['])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn comma_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![,])
@@ -346,7 +346,7 @@
 }
 impl ExprVar {
 	pub fn name(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -359,19 +359,19 @@
 		support::token(&self.syntax, T![if])
 	}
 	pub fn cond(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn then_kw_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![then])
 	}
 	pub fn then(&self) -> Option<TrueExpr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn else_kw_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![else])
 	}
 	pub fn else_(&self) -> Option<FalseExpr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -381,7 +381,7 @@
 }
 impl TrueExpr {
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -391,7 +391,7 @@
 }
 impl FalseExpr {
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -407,13 +407,13 @@
 		support::token(&self.syntax, T!['('])
 	}
 	pub fn params_desc(&self) -> Option<ParamsDesc> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![')'])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -442,7 +442,7 @@
 		support::token(&self.syntax, T![error])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -452,7 +452,7 @@
 }
 impl SliceDescEnd {
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -462,7 +462,7 @@
 }
 impl SliceDescStep {
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -472,13 +472,13 @@
 }
 impl Arg {
 	pub fn name(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn assign_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![=])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -523,7 +523,7 @@
 }
 impl MemberBindStmt {
 	pub fn obj_local(&self) -> Option<ObjLocal> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -536,7 +536,7 @@
 		support::token(&self.syntax, T![local])
 	}
 	pub fn bind(&self) -> Option<Bind> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -546,7 +546,7 @@
 }
 impl MemberAssertStmt {
 	pub fn assertion(&self) -> Option<Assertion> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -556,7 +556,7 @@
 }
 impl MemberFieldNormal {
 	pub fn field_name(&self) -> Option<FieldName> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn plus_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![+])
@@ -565,7 +565,7 @@
 		support::token_child(&self.syntax)
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -575,16 +575,16 @@
 }
 impl MemberFieldMethod {
 	pub fn field_name(&self) -> Option<FieldName> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn params_desc(&self) -> Option<ParamsDesc> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn visibility(&self) -> Option<Visibility> {
 		support::token_child(&self.syntax)
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -594,7 +594,7 @@
 }
 impl FieldNameFixed {
 	pub fn id(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn text(&self) -> Option<Text> {
 		support::token_child(&self.syntax)
@@ -610,7 +610,7 @@
 		support::token(&self.syntax, T!['['])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![']'])
@@ -626,13 +626,13 @@
 		support::token(&self.syntax, T![for])
 	}
 	pub fn bind(&self) -> Option<Destruct> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn in_kw_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![in])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -645,7 +645,7 @@
 		support::token(&self.syntax, T![if])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -655,13 +655,13 @@
 }
 impl BindDestruct {
 	pub fn into(&self) -> Option<Destruct> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn assign_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![=])
 	}
 	pub fn value(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -671,16 +671,16 @@
 }
 impl BindFunction {
 	pub fn name(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn params(&self) -> Option<ParamsDesc> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn assign_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![=])
 	}
 	pub fn value(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -690,13 +690,13 @@
 }
 impl Param {
 	pub fn destruct(&self) -> Option<Destruct> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn assign_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![=])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -706,7 +706,7 @@
 }
 impl DestructFull {
 	pub fn name(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -748,7 +748,7 @@
 		support::children(&self.syntax)
 	}
 	pub fn destruct_rest(&self) -> Option<DestructRest> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn comma_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![,])
@@ -764,19 +764,19 @@
 }
 impl DestructObjectField {
 	pub fn field(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn colon_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![:])
 	}
 	pub fn destruct(&self) -> Option<Destruct> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 	pub fn assign_token(&self) -> Option<SyntaxToken> {
 		support::token(&self.syntax, T![=])
 	}
 	pub fn expr(&self) -> Option<Expr> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -789,7 +789,7 @@
 		support::token(&self.syntax, T![...])
 	}
 	pub fn into(&self) -> Option<Name> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
 
@@ -799,7 +799,7 @@
 }
 impl DestructArrayElement {
 	pub fn destruct(&self) -> Option<Destruct> {
-		support::child(&self.syntax)
+		support::children(&self.syntax).next()
 	}
 }
modifiedxtask/src/sourcegen/mod.rsdiffbeforeafterboth
before · xtask/src/sourcegen/mod.rs
1use std::path::PathBuf;23use anyhow::Result;4use ast::{lower, AstSrc};5use itertools::Itertools;6use kinds::{KindsSrc, TokenKind};7use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};8use quote::{format_ident, quote};9use ungrammar::Grammar;10use util::{ensure_file_contents, reformat, to_pascal_case, to_upper_snake_case};1112mod ast;13mod kinds;14mod util;1516enum SpecialName {17	Literal,18	Meta,19	Error,20}21fn classify_special(name: &str) -> Option<(SpecialName, &str)> {22	let name = name.strip_suffix('!')?;23	Some(if let Some(name) = name.strip_prefix("LIT_") {24		(SpecialName::Literal, name)25	} else if let Some(name) = name.strip_prefix("META_") {26		(SpecialName::Meta, name)27	} else if let Some(name) = name.strip_prefix("ERROR_") {28		(SpecialName::Error, name)29	} else {30		return None;31	})32}3334pub fn generate_ungrammar() -> Result<()> {35	let grammar: Grammar = include_str!(concat!(36		env!("CARGO_MANIFEST_DIR"),37		"/../crates/jrsonnet-rowan-parser/jsonnet.ungram"38	))39	.parse()?;4041	let mut kinds = kinds::jsonnet_kinds();42	let ast = lower(&kinds, &grammar);4344	for token in grammar.tokens() {45		let token = &grammar[token];46		let token = &token.name.clone();47		if !kinds.is_token(token) {48			if let Some((special, name)) = classify_special(token) {49				match special {50					SpecialName::Literal => panic!("literal is not defined: {name}"),51					SpecialName::Meta => {52						eprintln!("implicit meta: {name}");53						kinds.define_token(TokenKind::Meta {54							grammar_name: token.to_owned(),55							name: format!("META_{name}"),56						});57					}58					SpecialName::Error => {59						eprintln!("implicit error: {name}");60						kinds.define_token(TokenKind::Error {61							grammar_name: token.to_owned(),62							name: format!("ERROR_{name}"),63							regex: None,64							priority: None,65							is_lexer_error: true,66						});67					}68				};69				continue;70			};71			let name = to_upper_snake_case(token);72			eprintln!("implicit kw: {token}");73			kinds.define_token(TokenKind::Keyword {74				code: token.to_owned(),75				name: format!("{name}_KW"),76			});77		}78	}79	for node in &ast.nodes {80		let name = to_upper_snake_case(&node.name);81		kinds.define_node(&name);82	}83	for enum_ in &ast.enums {84		let name = to_upper_snake_case(&enum_.name);85		kinds.define_node(&name);86	}87	for token_enum in &ast.token_enums {88		let name = to_upper_snake_case(&token_enum.name);89		kinds.define_node(&name);90	}9192	let syntax_kinds = generate_syntax_kinds(&kinds, &ast)?;9394	let nodes = generate_nodes(&kinds, &ast)?;95	ensure_file_contents(96		&PathBuf::from(concat!(97			env!("CARGO_MANIFEST_DIR"),98			"/../crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rs",99		)),100		&syntax_kinds,101	);102	ensure_file_contents(103		&PathBuf::from(concat!(104			env!("CARGO_MANIFEST_DIR"),105			"/../crates/jrsonnet-rowan-parser/src/generated/nodes.rs",106		)),107		&nodes,108	);109	Ok(())110}111112fn generate_syntax_kinds(kinds: &KindsSrc, grammar: &AstSrc) -> Result<String> {113	let t_macros = kinds.tokens().filter_map(TokenKind::expand_t_macros);114	let token_kinds = kinds.tokens().map(TokenKind::expand_kind);115116	let keywords = kinds117		.tokens()118		.filter(|k| matches!(k, TokenKind::Keyword { .. }))119		.map(TokenKind::name)120		.map(|n| format_ident!("{n}"));121122	let nodes = kinds123		.nodes124		.iter()125		.map(|name| format_ident!("{}", name))126		.collect::<Vec<_>>();127128	let enums = grammar129		.enums130		.iter()131		.map(|e| format_ident!("{}", to_upper_snake_case(&e.name)))132		.chain(133			grammar134				.token_enums135				.iter()136				.map(|e| format_ident!("{}", to_upper_snake_case(&e.name))),137		);138139	let ast = quote! {140		#![allow(bad_style, missing_docs, unreachable_pub, clippy::manual_non_exhaustive, clippy::match_like_matches_macro)]141		use logos::Logos;142143		/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT`.144		#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Logos)]145		#[repr(u16)]146		pub enum SyntaxKind {147			#[doc(hidden)]148			TOMBSTONE,149			#[doc(hidden)]150			EOF,151			#(#token_kinds,)*152			LEXING_ERROR,153			__LAST_TOKEN,154			#(#nodes,)*155			#[doc(hidden)]156			__LAST,157		}158		use self::SyntaxKind::*;159160		impl SyntaxKind {161			pub fn is_keyword(self) -> bool {162				match self {163					#(#keywords)|* => true,164					_ => false,165				}166			}167			pub fn is_enum(self) -> bool {168				match self {169					#(#enums)|* => true,170					_ => false,171				}172			}173174			pub fn from_raw(r: u16) -> Self {175				assert!(r < Self::__LAST as u16);176				unsafe { std::mem::transmute(r) }177			}178			pub fn into_raw(self) -> u16 {179				self as u16180			}181		}182183		#[macro_export]184		macro_rules! T {#(#t_macros);*}185		#[allow(unused_imports)]186		pub use T;187	};188189	reformat(&ast.to_string())190}191192#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]193fn generate_nodes(kinds: &KindsSrc, grammar: &AstSrc) -> Result<String> {194	let (node_defs, node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar195		.nodes196		.iter()197		.map(|node| {198			let name = format_ident!("{}", node.name);199			let kind = format_ident!("{}", to_upper_snake_case(&node.name));200			let traits = node.traits.iter().map(|trait_name| {201				let trait_name = format_ident!("{}", trait_name);202				quote!(impl ast::#trait_name for #name {})203			});204205			let methods = node.fields.iter().map(|field| {206				let method_name = field.method_name(kinds);207				let ty = field.ty();208209				if field.is_many() {210					quote! {211						pub fn #method_name(&self) -> AstChildren<#ty> {212							support::children(&self.syntax)213						}214					}215				} else if let Some(token_kind) = field.token_kind(kinds) {216					quote! {217						pub fn #method_name(&self) -> Option<#ty> {218							support::token(&self.syntax, #token_kind)219						}220					}221				} else if field.is_token_enum(grammar) {222					quote! {223						pub fn #method_name(&self) -> Option<#ty> {224							support::token_child(&self.syntax)225						}226					}227				} else {228					quote! {229						pub fn #method_name(&self) -> Option<#ty> {230							support::child(&self.syntax)231						}232					}233				}234			});235			(236				quote! {237					#[pretty_doc_comment_placeholder_workaround]238					#[derive(Debug, Clone, PartialEq, Eq, Hash)]239					pub struct #name {240						pub(crate) syntax: SyntaxNode,241					}242243					#(#traits)*244245					impl #name {246						#(#methods)*247					}248				},249				quote! {250					impl AstNode for #name {251						fn can_cast(kind: SyntaxKind) -> bool {252							kind == #kind253						}254						fn cast(syntax: SyntaxNode) -> Option<Self> {255							if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }256						}257						fn syntax(&self) -> &SyntaxNode { &self.syntax }258					}259				},260			)261		})262		.unzip();263264	let (enum_defs, enum_boilerplate_impls): (Vec<_>, Vec<_>) = grammar265		.enums266		.iter()267		.map(|en| {268			let variants: Vec<_> = en269				.variants270				.iter()271				.map(|var| format_ident!("{}", var))272				.collect();273			let name = format_ident!("{}", en.name);274			let kinds: Vec<_> = variants275				.iter()276				.map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string())))277				.collect();278			let traits = en.traits.iter().map(|trait_name| {279				let trait_name = format_ident!("{}", trait_name);280				quote!(impl ast::#trait_name for #name {})281			});282283			let ast_node = quote! {284				impl AstNode for #name {285					fn can_cast(kind: SyntaxKind) -> bool {286						match kind {287							#(#kinds)|* => true,288							_ => false,289						}290					}291					fn cast(syntax: SyntaxNode) -> Option<Self> {292						let res = match syntax.kind() {293							#(294							#kinds => #name::#variants(#variants { syntax }),295							)*296							_ => return None,297						};298						Some(res)299					}300					fn syntax(&self) -> &SyntaxNode {301						match self {302							#(303							#name::#variants(it) => &it.syntax,304							)*305						}306					}307				}308			};309310			(311				quote! {312					#[pretty_doc_comment_placeholder_workaround]313					#[derive(Debug, Clone, PartialEq, Eq, Hash)]314					pub enum #name {315						#(#variants(#variants),)*316					}317318					#(#traits)*319				},320				quote! {321					#(322						impl From<#variants> for #name {323							fn from(node: #variants) -> #name {324								#name::#variants(node)325							}326						}327					)*328					#ast_node329				},330			)331		})332		.unzip();333334	let (token_enum_defs, token_enum_boilerplate_impls): (Vec<_>, Vec<_>) = grammar335		.token_enums336		.iter()337		.map(|en| {338			let variants: Vec<_> = en339				.variants340				.iter()341				.map(|token| {342					format_ident!(343						"{}",344						to_pascal_case(kinds.token(token).expect("token exists").name())345					)346				})347				.collect();348			let name = format_ident!("{}", en.name);349			let kind_name = format_ident!("{}Kind", en.name);350			let kinds: Vec<_> = variants351				.iter()352				.map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string())))353				.collect();354355			let ast_node = quote! {356				impl AstToken for #name {357					fn can_cast(kind: SyntaxKind) -> bool {358						#kind_name::can_cast(kind)359					}360					fn cast(syntax: SyntaxToken) -> Option<Self> {361						let kind = #kind_name::cast(syntax.kind())?;362						Some(#name { syntax, kind })363					}364					fn syntax(&self) -> &SyntaxToken {365						&self.syntax366					}367				}368369				impl #kind_name {370					fn can_cast(kind: SyntaxKind) -> bool {371						match kind {372							#(#kinds)|* => true,373							_ => false,374						}375					}376					pub fn cast(kind: SyntaxKind) -> Option<Self> {377						let res = match kind {378							#(#kinds => Self::#variants,)*379							_ => return None,380						};381						Some(res)382					}383				}384			};385386			(387				quote! {388					#[pretty_doc_comment_placeholder_workaround]389					#[derive(Debug, Clone, PartialEq, Eq, Hash)]390					pub struct #name { syntax: SyntaxToken, kind: #kind_name }391392					#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]393					pub enum #kind_name {394						#(#variants,)*395					}396				},397				quote! {398					#ast_node399400					impl #name {401						pub fn kind(&self) -> #kind_name {402							self.kind403						}404					}405406					impl std::fmt::Display for #name {407						fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {408							std::fmt::Display::fmt(self.syntax(), f)409						}410					}411				},412			)413		})414		.unzip();415416	let (any_node_defs, any_node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar417		.nodes418		.iter()419		.flat_map(|node| node.traits.iter().map(move |t| (t, node)))420		.into_group_map()421		.into_iter()422		.sorted_by_key(|(k, _)| *k)423		.map(|(trait_name, nodes)| {424			let name = format_ident!("Any{}", trait_name);425			let trait_name = format_ident!("{}", trait_name);426			let kinds: Vec<_> = nodes427				.iter()428				.map(|name| format_ident!("{}", to_upper_snake_case(&name.name.to_string())))429				.collect();430431			(432				quote! {433					#[pretty_doc_comment_placeholder_workaround]434					#[derive(Debug, Clone, PartialEq, Eq, Hash)]435					pub struct #name {436						pub(crate) syntax: SyntaxNode,437					}438					impl ast::#trait_name for #name {}439				},440				quote! {441					impl #name {442						#[inline]443						pub fn new<T: ast::#trait_name>(node: T) -> #name {444							#name {445								syntax: node.syntax().clone()446							}447						}448					}449					impl AstNode for #name {450						fn can_cast(kind: SyntaxKind) -> bool {451							match kind {452								#(#kinds)|* => true,453								_ => false,454							}455						}456						fn cast(syntax: SyntaxNode) -> Option<Self> {457							Self::can_cast(syntax.kind()).then(|| #name { syntax })458						}459						fn syntax(&self) -> &SyntaxNode {460							&self.syntax461						}462					}463				},464			)465		})466		.unzip();467468	let enum_names = grammar.enums.iter().map(|it| &it.name);469	let node_names = grammar.nodes.iter().map(|it| &it.name);470471	let display_impls = enum_names472		.chain(node_names.clone())473		.map(|it| format_ident!("{}", it))474		.map(|name| {475			quote! {476				impl std::fmt::Display for #name {477					fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {478						std::fmt::Display::fmt(self.syntax(), f)479					}480				}481			}482		});483484	let ast = quote! {485		#![allow(non_snake_case, clippy::match_like_matches_macro)]486487		use crate::{488			SyntaxNode, SyntaxToken, SyntaxKind::{self, *},489			ast::{AstNode, AstToken, AstChildren, support},490			T,491		};492493		#(#node_defs)*494		#(#enum_defs)*495		#(#token_enum_defs)*496		#(#any_node_defs)*497		#(#node_boilerplate_impls)*498		#(#enum_boilerplate_impls)*499		#(#token_enum_boilerplate_impls)*500		#(#any_node_boilerplate_impls)*501		#(#display_impls)*502	};503504	let ast = ast.to_string().replace("T ! [", "T![");505506	let mut res = String::with_capacity(ast.len() * 2);507508	let mut docs = grammar509		.nodes510		.iter()511		.map(|it| &it.doc)512		.chain(grammar.enums.iter().map(|it| &it.doc));513514	for chunk in ast.split("# [pretty_doc_comment_placeholder_workaround] ") {515		res.push_str(chunk);516		if let Some(doc) = docs.next() {517			write_doc_comment(doc, &mut res);518		}519	}520521	let res = reformat(&res)?;522	Ok(res.replace("#[derive", "\n#[derive"))523}524525fn write_doc_comment(contents: &[String], dest: &mut String) {526	use std::fmt::Write;527	for line in contents {528		writeln!(dest, "///{line}").unwrap();529	}530}531532pub fn escape_token_macro(token: &str) -> TokenStream {533	if "{}[]()$".contains(token) {534		let c = token.chars().next().unwrap();535		quote! { #c }536	} else if token.contains(|v| v == '$') {537		quote! { #token }538	} else if token.chars().all(|v| ('a'..='z').contains(&v)) {539		let i = Ident::new(&token, Span::call_site());540		quote! { #i }541	} else {542		let cs = token.chars().map(|c| Punct::new(c, Spacing::Joint));543		quote! { #(#cs)* }544	}545}
after · xtask/src/sourcegen/mod.rs
1use std::{collections::HashMap, path::PathBuf};23use anyhow::Result;4use ast::{lower, AstSrc};5use itertools::Itertools;6use kinds::{KindsSrc, TokenKind};7use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};8use quote::{format_ident, quote};9use ungrammar::Grammar;10use util::{ensure_file_contents, reformat, to_pascal_case, to_upper_snake_case};1112mod ast;13mod kinds;14mod util;1516enum SpecialName {17	Literal,18	Meta,19	Error,20}21fn classify_special(name: &str) -> Option<(SpecialName, &str)> {22	let name = name.strip_suffix('!')?;23	Some(if let Some(name) = name.strip_prefix("LIT_") {24		(SpecialName::Literal, name)25	} else if let Some(name) = name.strip_prefix("META_") {26		(SpecialName::Meta, name)27	} else if let Some(name) = name.strip_prefix("ERROR_") {28		(SpecialName::Error, name)29	} else {30		return None;31	})32}3334pub fn generate_ungrammar() -> Result<()> {35	let grammar: Grammar = include_str!(concat!(36		env!("CARGO_MANIFEST_DIR"),37		"/../crates/jrsonnet-rowan-parser/jsonnet.ungram"38	))39	.parse()?;4041	let mut kinds = kinds::jsonnet_kinds();42	let ast = lower(&kinds, &grammar);4344	for token in grammar.tokens() {45		let token = &grammar[token];46		let token = &token.name.clone();47		if !kinds.is_token(token) {48			if let Some((special, name)) = classify_special(token) {49				match special {50					SpecialName::Literal => panic!("literal is not defined: {name}"),51					SpecialName::Meta => {52						eprintln!("implicit meta: {name}");53						kinds.define_token(TokenKind::Meta {54							grammar_name: token.to_owned(),55							name: format!("META_{name}"),56						});57					}58					SpecialName::Error => {59						eprintln!("implicit error: {name}");60						kinds.define_token(TokenKind::Error {61							grammar_name: token.to_owned(),62							name: format!("ERROR_{name}"),63							regex: None,64							priority: None,65							is_lexer_error: true,66						});67					}68				};69				continue;70			};71			let name = to_upper_snake_case(token);72			eprintln!("implicit kw: {token}");73			kinds.define_token(TokenKind::Keyword {74				code: token.to_owned(),75				name: format!("{name}_KW"),76			});77		}78	}79	for node in &ast.nodes {80		let name = to_upper_snake_case(&node.name);81		kinds.define_node(&name);82	}83	for enum_ in &ast.enums {84		let name = to_upper_snake_case(&enum_.name);85		kinds.define_node(&name);86	}87	for token_enum in &ast.token_enums {88		let name = to_upper_snake_case(&token_enum.name);89		kinds.define_node(&name);90	}9192	let syntax_kinds = generate_syntax_kinds(&kinds, &ast)?;9394	let nodes = generate_nodes(&kinds, &ast)?;95	ensure_file_contents(96		&PathBuf::from(concat!(97			env!("CARGO_MANIFEST_DIR"),98			"/../crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rs",99		)),100		&syntax_kinds,101	);102	ensure_file_contents(103		&PathBuf::from(concat!(104			env!("CARGO_MANIFEST_DIR"),105			"/../crates/jrsonnet-rowan-parser/src/generated/nodes.rs",106		)),107		&nodes,108	);109	Ok(())110}111112fn generate_syntax_kinds(kinds: &KindsSrc, grammar: &AstSrc) -> Result<String> {113	let t_macros = kinds.tokens().filter_map(TokenKind::expand_t_macros);114	let token_kinds = kinds.tokens().map(TokenKind::expand_kind);115116	let keywords = kinds117		.tokens()118		.filter(|k| matches!(k, TokenKind::Keyword { .. }))119		.map(TokenKind::name)120		.map(|n| format_ident!("{n}"));121122	let nodes = kinds123		.nodes124		.iter()125		.map(|name| format_ident!("{}", name))126		.collect::<Vec<_>>();127128	let enums = grammar129		.enums130		.iter()131		.map(|e| format_ident!("{}", to_upper_snake_case(&e.name)))132		.chain(133			grammar134				.token_enums135				.iter()136				.map(|e| format_ident!("{}", to_upper_snake_case(&e.name))),137		);138139	let ast = quote! {140		#![allow(bad_style, missing_docs, unreachable_pub, clippy::manual_non_exhaustive, clippy::match_like_matches_macro)]141		use logos::Logos;142143		/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT`.144		#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Logos)]145		#[repr(u16)]146		pub enum SyntaxKind {147			#[doc(hidden)]148			TOMBSTONE,149			#[doc(hidden)]150			EOF,151			#(#token_kinds,)*152			LEXING_ERROR,153			__LAST_TOKEN,154			#(#nodes,)*155			#[doc(hidden)]156			__LAST,157		}158		use self::SyntaxKind::*;159160		impl SyntaxKind {161			pub fn is_keyword(self) -> bool {162				match self {163					#(#keywords)|* => true,164					_ => false,165				}166			}167			pub fn is_enum(self) -> bool {168				match self {169					#(#enums)|* => true,170					_ => false,171				}172			}173174			pub fn from_raw(r: u16) -> Self {175				assert!(r < Self::__LAST as u16);176				unsafe { std::mem::transmute(r) }177			}178			pub fn into_raw(self) -> u16 {179				self as u16180			}181		}182183		#[macro_export]184		macro_rules! T {#(#t_macros);*}185		#[allow(unused_imports)]186		pub use T;187	};188189	reformat(&ast.to_string())190}191192#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]193fn generate_nodes(kinds: &KindsSrc, grammar: &AstSrc) -> Result<String> {194	let (node_defs, node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar195		.nodes196		.iter()197		.map(|node| {198			let name = format_ident!("{}", node.name);199			let kind = format_ident!("{}", to_upper_snake_case(&node.name));200			let traits = node.traits.iter().map(|trait_name| {201				let trait_name = format_ident!("{}", trait_name);202				quote!(impl ast::#trait_name for #name {})203			});204205			let mut type_positions: HashMap<String, usize> = HashMap::new();206			let field_positions: Vec<_> = node.fields.iter().map(|field| {207				let ty_str = field.ty().to_string();208				let pos = *type_positions.get(&ty_str).unwrap_or(&0);209				type_positions.insert(ty_str, pos + 1);210				pos211			}).collect();212213			let methods = node.fields.iter().zip(field_positions.iter()).map(|(field, &pos)| {214				let method_name = field.method_name(kinds);215				let ty = field.ty();216217				if field.is_many() {218					quote! {219						pub fn #method_name(&self) -> AstChildren<#ty> {220							support::children(&self.syntax)221						}222					}223				} else if let Some(token_kind) = field.token_kind(kinds) {224					quote! {225						pub fn #method_name(&self) -> Option<#ty> {226							support::token(&self.syntax, #token_kind)227						}228					}229				} else if field.is_token_enum(grammar) {230					quote! {231						pub fn #method_name(&self) -> Option<#ty> {232							support::token_child(&self.syntax)233						}234					}235				} else if pos == 0 {236					quote! {237						pub fn #method_name(&self) -> Option<#ty> {238							support::children(&self.syntax).next()239						}240					}241				} else {242					quote! {243						pub fn #method_name(&self) -> Option<#ty> {244							support::children(&self.syntax).nth(#pos)245						}246					}247				}248			});249			(250				quote! {251					#[pretty_doc_comment_placeholder_workaround]252					#[derive(Debug, Clone, PartialEq, Eq, Hash)]253					pub struct #name {254						pub(crate) syntax: SyntaxNode,255					}256257					#(#traits)*258259					impl #name {260						#(#methods)*261					}262				},263				quote! {264					impl AstNode for #name {265						fn can_cast(kind: SyntaxKind) -> bool {266							kind == #kind267						}268						fn cast(syntax: SyntaxNode) -> Option<Self> {269							if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }270						}271						fn syntax(&self) -> &SyntaxNode { &self.syntax }272					}273				},274			)275		})276		.unzip();277278	let (enum_defs, enum_boilerplate_impls): (Vec<_>, Vec<_>) = grammar279		.enums280		.iter()281		.map(|en| {282			let variants: Vec<_> = en283				.variants284				.iter()285				.map(|var| format_ident!("{}", var))286				.collect();287			let name = format_ident!("{}", en.name);288			let kinds: Vec<_> = variants289				.iter()290				.map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string())))291				.collect();292			let traits = en.traits.iter().map(|trait_name| {293				let trait_name = format_ident!("{}", trait_name);294				quote!(impl ast::#trait_name for #name {})295			});296297			let ast_node = quote! {298				impl AstNode for #name {299					fn can_cast(kind: SyntaxKind) -> bool {300						match kind {301							#(#kinds)|* => true,302							_ => false,303						}304					}305					fn cast(syntax: SyntaxNode) -> Option<Self> {306						let res = match syntax.kind() {307							#(308							#kinds => #name::#variants(#variants { syntax }),309							)*310							_ => return None,311						};312						Some(res)313					}314					fn syntax(&self) -> &SyntaxNode {315						match self {316							#(317							#name::#variants(it) => &it.syntax,318							)*319						}320					}321				}322			};323324			(325				quote! {326					#[pretty_doc_comment_placeholder_workaround]327					#[derive(Debug, Clone, PartialEq, Eq, Hash)]328					pub enum #name {329						#(#variants(#variants),)*330					}331332					#(#traits)*333				},334				quote! {335					#(336						impl From<#variants> for #name {337							fn from(node: #variants) -> #name {338								#name::#variants(node)339							}340						}341					)*342					#ast_node343				},344			)345		})346		.unzip();347348	let (token_enum_defs, token_enum_boilerplate_impls): (Vec<_>, Vec<_>) = grammar349		.token_enums350		.iter()351		.map(|en| {352			let variants: Vec<_> = en353				.variants354				.iter()355				.map(|token| {356					format_ident!(357						"{}",358						to_pascal_case(kinds.token(token).expect("token exists").name())359					)360				})361				.collect();362			let name = format_ident!("{}", en.name);363			let kind_name = format_ident!("{}Kind", en.name);364			let kinds: Vec<_> = variants365				.iter()366				.map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string())))367				.collect();368369			let ast_node = quote! {370				impl AstToken for #name {371					fn can_cast(kind: SyntaxKind) -> bool {372						#kind_name::can_cast(kind)373					}374					fn cast(syntax: SyntaxToken) -> Option<Self> {375						let kind = #kind_name::cast(syntax.kind())?;376						Some(#name { syntax, kind })377					}378					fn syntax(&self) -> &SyntaxToken {379						&self.syntax380					}381				}382383				impl #kind_name {384					fn can_cast(kind: SyntaxKind) -> bool {385						match kind {386							#(#kinds)|* => true,387							_ => false,388						}389					}390					pub fn cast(kind: SyntaxKind) -> Option<Self> {391						let res = match kind {392							#(#kinds => Self::#variants,)*393							_ => return None,394						};395						Some(res)396					}397				}398			};399400			(401				quote! {402					#[pretty_doc_comment_placeholder_workaround]403					#[derive(Debug, Clone, PartialEq, Eq, Hash)]404					pub struct #name { syntax: SyntaxToken, kind: #kind_name }405406					#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]407					pub enum #kind_name {408						#(#variants,)*409					}410				},411				quote! {412					#ast_node413414					impl #name {415						pub fn kind(&self) -> #kind_name {416							self.kind417						}418					}419420					impl std::fmt::Display for #name {421						fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {422							std::fmt::Display::fmt(self.syntax(), f)423						}424					}425				},426			)427		})428		.unzip();429430	let (any_node_defs, any_node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar431		.nodes432		.iter()433		.flat_map(|node| node.traits.iter().map(move |t| (t, node)))434		.into_group_map()435		.into_iter()436		.sorted_by_key(|(k, _)| *k)437		.map(|(trait_name, nodes)| {438			let name = format_ident!("Any{}", trait_name);439			let trait_name = format_ident!("{}", trait_name);440			let kinds: Vec<_> = nodes441				.iter()442				.map(|name| format_ident!("{}", to_upper_snake_case(&name.name.to_string())))443				.collect();444445			(446				quote! {447					#[pretty_doc_comment_placeholder_workaround]448					#[derive(Debug, Clone, PartialEq, Eq, Hash)]449					pub struct #name {450						pub(crate) syntax: SyntaxNode,451					}452					impl ast::#trait_name for #name {}453				},454				quote! {455					impl #name {456						#[inline]457						pub fn new<T: ast::#trait_name>(node: T) -> #name {458							#name {459								syntax: node.syntax().clone()460							}461						}462					}463					impl AstNode for #name {464						fn can_cast(kind: SyntaxKind) -> bool {465							match kind {466								#(#kinds)|* => true,467								_ => false,468							}469						}470						fn cast(syntax: SyntaxNode) -> Option<Self> {471							Self::can_cast(syntax.kind()).then(|| #name { syntax })472						}473						fn syntax(&self) -> &SyntaxNode {474							&self.syntax475						}476					}477				},478			)479		})480		.unzip();481482	let enum_names = grammar.enums.iter().map(|it| &it.name);483	let node_names = grammar.nodes.iter().map(|it| &it.name);484485	let display_impls = enum_names486		.chain(node_names.clone())487		.map(|it| format_ident!("{}", it))488		.map(|name| {489			quote! {490				impl std::fmt::Display for #name {491					fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {492						std::fmt::Display::fmt(self.syntax(), f)493					}494				}495			}496		});497498	let ast = quote! {499		#![allow(non_snake_case, clippy::match_like_matches_macro)]500501		use crate::{502			SyntaxNode, SyntaxToken, SyntaxKind::{self, *},503			ast::{AstNode, AstToken, AstChildren, support},504			T,505		};506507		#(#node_defs)*508		#(#enum_defs)*509		#(#token_enum_defs)*510		#(#any_node_defs)*511		#(#node_boilerplate_impls)*512		#(#enum_boilerplate_impls)*513		#(#token_enum_boilerplate_impls)*514		#(#any_node_boilerplate_impls)*515		#(#display_impls)*516	};517518	let ast = ast.to_string().replace("T ! [", "T![");519520	let mut res = String::with_capacity(ast.len() * 2);521522	let mut docs = grammar523		.nodes524		.iter()525		.map(|it| &it.doc)526		.chain(grammar.enums.iter().map(|it| &it.doc));527528	for chunk in ast.split("# [pretty_doc_comment_placeholder_workaround] ") {529		res.push_str(chunk);530		if let Some(doc) = docs.next() {531			write_doc_comment(doc, &mut res);532		}533	}534535	let res = reformat(&res)?;536	Ok(res.replace("#[derive", "\n#[derive"))537}538539fn write_doc_comment(contents: &[String], dest: &mut String) {540	use std::fmt::Write;541	for line in contents {542		writeln!(dest, "///{line}").unwrap();543	}544}545546pub fn escape_token_macro(token: &str) -> TokenStream {547	if "{}[]()$".contains(token) {548		let c = token.chars().next().unwrap();549		quote! { #c }550	} else if token.contains(|v| v == '$') {551		quote! { #token }552	} else if token.chars().all(|v| ('a'..='z').contains(&v)) {553		let i = Ident::new(&token, Span::call_site());554		quote! { #i }555	} else {556		let cs = token.chars().map(|c| Punct::new(c, Spacing::Joint));557		quote! { #(#cs)* }558	}559}