git.delta.rocks / jrsonnet / refs/commits / 4ebc2d766e69

--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,2 @@
+[alias]
+xtask = "run --package xtask --bin xtask --"

--- /dev/null
+++ b/cmds/jrsonnet-fmt/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "jrsonnet-fmt"
+version.workspace = true
+edition = "2021"
+
+[dependencies]
+dprint-core = "0.63.2"
+jrsonnet-rowan-parser.workspace = true
+insta = "1.15"
+indoc = "1.0"
+ass-stroke = { git = "https://github.com/CertainLach/ass-stroke.git", version = "0.1.0" }
+clap = { version = "4.4.2", features = ["derive"] }
+tempfile = "3.8.0"
+thiserror = "1.0.48"

--- /dev/null
+++ b/cmds/jrsonnet-fmt/src/children.rs
@@ -0,0 +1,290 @@
+// TODO: Return errors as trivia
+
+use std::{fmt::Debug, mem};
+
+use jrsonnet_rowan_parser::{
+	nodes::{CustomError, Trivia, TriviaKind},
+	AstNode, AstToken, SyntaxElement, SyntaxNode, TS,
+};
+
+pub type ChildTrivia = Vec<Result<Trivia, String>>;
+
+/// Node should have no non-trivia tokens before element
+pub fn trivia_before(node: SyntaxNode, end: Option<&SyntaxElement>) -> ChildTrivia {
+	let mut out = Vec::new();
+	for item in node.children_with_tokens() {
+		if Some(&item) == end {
+			break;
+		}
+
+		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			out.push(Ok(trivia));
+		} else if CustomError::can_cast(item.kind()) {
+			out.push(Err(item.to_string()));
+		} else if end.is_none() {
+			break;
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			)
+		}
+	}
+	out
+}
+/// Node should have no non-trivia tokens after element
+pub fn trivia_after(node: SyntaxNode, start: Option<&SyntaxElement>) -> ChildTrivia {
+	if start.is_none() {
+		return Vec::new();
+	}
+	let mut iter = node.children_with_tokens().peekable();
+	while iter.peek() != start {
+		iter.next();
+	}
+	iter.next();
+	let mut out = Vec::new();
+	for item in iter {
+		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			out.push(Ok(trivia));
+		} else if CustomError::can_cast(item.kind()) {
+			out.push(Err(item.to_string()))
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			)
+		}
+	}
+	out
+}
+
+pub fn trivia_between(
+	node: SyntaxNode,
+	start: Option<&SyntaxElement>,
+	end: Option<&SyntaxElement>,
+) -> EndingComments {
+	let mut iter = node.children_with_tokens().peekable();
+	while iter.peek() != start {
+		iter.next();
+	}
+	iter.next();
+
+	let loose = start.is_none() || end.is_none();
+
+	let mut out = Vec::new();
+	for item in iter.take_while(|i| Some(i) != end) {
+		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			out.push(Ok(trivia));
+		} else if CustomError::can_cast(item.kind()) {
+			out.push(Err(item.to_string()))
+		} else if loose {
+			break;
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			)
+		}
+	}
+	EndingComments {
+		should_start_with_newline: should_start_with_newline(None, &out),
+		trivia: out,
+	}
+}
+
+pub fn children_between<T: AstNode + Debug>(
+	node: SyntaxNode,
+	start: Option<&SyntaxElement>,
+	end: Option<&SyntaxElement>,
+	trailing: Option<ChildTrivia>,
+) -> (Vec<Child<T>>, EndingComments) {
+	let mut iter = node.children_with_tokens().peekable();
+	if start.is_some() {
+		while iter.peek() != start {
+			iter.next();
+		}
+		iter.next();
+	}
+	children(
+		iter.take_while(|i| Some(i) != end),
+		start.is_none() && end.is_none(),
+		trailing,
+	)
+}
+
+pub fn should_start_with_newline(prev_inline: Option<&ChildTrivia>, tt: &ChildTrivia) -> bool {
+	count_newlines_before(tt)
+		+ prev_inline
+			.map(count_newlines_after)
+			.unwrap_or_default()
+
+		// First for previous item end, second for current item
+		>= 2
+}
+
+fn count_newlines_before(tt: &ChildTrivia) -> usize {
+	let mut nl_count = 0;
+	for t in tt {
+		match t {
+			Ok(t) => match t.kind() {
+				TriviaKind::Whitespace => {
+					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
+				}
+				_ => break,
+			},
+			Err(_) => {
+				nl_count += 1;
+			}
+		}
+	}
+	nl_count
+}
+fn count_newlines_after(tt: &ChildTrivia) -> usize {
+	let mut nl_count = 0;
+	for t in tt.iter().rev() {
+		match t {
+			Ok(t) => match t.kind() {
+				TriviaKind::Whitespace => {
+					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
+				}
+				TriviaKind::SingleLineHashComment => {
+					nl_count += 1;
+					break;
+				}
+				TriviaKind::SingleLineSlashComment => {
+					nl_count += 1;
+					break;
+				}
+				_ => {}
+			},
+			Err(_) => nl_count += 1,
+		}
+	}
+	nl_count
+}
+
+pub fn children<T: AstNode + Debug>(
+	items: impl Iterator<Item = SyntaxElement>,
+	loose: bool,
+	mut trailing: Option<ChildTrivia>,
+) -> (Vec<Child<T>>, EndingComments) {
+	let mut out = Vec::new();
+	let mut current_child = None::<Child<T>>;
+	let mut next = ChildTrivia::new();
+	// Previous element ended, do not add more inline comments
+	let mut started_next = false;
+	let mut had_some = false;
+
+	for item in items {
+		if let Some(value) = item.as_node().cloned().and_then(T::cast) {
+			let before_trivia = if let Some(trailing) = trailing.take() {
+				assert!(next.is_empty());
+				trailing
+			} else {
+				mem::take(&mut next)
+			};
+			let last_child = current_child.replace(Child {
+				// First item should not start with newline
+				should_start_with_newline: had_some
+					&& should_start_with_newline(
+						current_child.as_ref().map(|c| &c.inline_trivia),
+						&before_trivia,
+					),
+				before_trivia,
+				value,
+				inline_trivia: Vec::new(),
+			});
+			if let Some(last_child) = last_child {
+				out.push(last_child)
+			}
+			had_some = true;
+			started_next = false;
+		} else if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
+			let is_single_line_comment = trivia.kind() == TriviaKind::SingleLineHashComment
+				|| trivia.kind() == TriviaKind::SingleLineSlashComment;
+			if trailing.is_some() {
+				// Someone have already parsed trivia for us
+				continue;
+			} else if started_next
+				|| current_child.is_none()
+				|| trivia.text().contains('\n') && !is_single_line_comment
+			{
+				next.push(Ok(trivia.clone()));
+				started_next = true;
+			} else {
+				let cur = current_child.as_mut().expect("checked not none");
+				cur.inline_trivia.push(Ok(trivia));
+				if is_single_line_comment {
+					started_next = true;
+				}
+			}
+			had_some = true;
+		} else if CustomError::can_cast(item.kind()) {
+			next.push(Err(item.to_string()))
+		} else if loose {
+			if had_some {
+				break;
+			}
+			started_next = true;
+		} else {
+			assert!(
+				TS![, ;].contains(item.kind()),
+				"silently eaten token: {:?}",
+				item.kind()
+			)
+		}
+	}
+
+	let ending_comments = EndingComments {
+		should_start_with_newline: should_start_with_newline(
+			current_child.as_ref().map(|c| &c.inline_trivia),
+			&next,
+		),
+		trivia: next,
+	};
+
+	if let Some(current_child) = current_child {
+		out.push(current_child);
+	}
+
+	(out, ending_comments)
+}
+
+#[derive(Debug)]
+pub struct Child<T> {
+	/// If this child has two newlines above in source code, so it needs to have it in the output
+	pub should_start_with_newline: bool,
+	/// Comment before item, i.e
+	///
+	/// ```ignore
+	/// // Comment
+	/// item
+	/// ```
+	pub before_trivia: ChildTrivia,
+	pub value: T,
+	/// Comment after line, but located at same line
+	///
+	/// ```ignore
+	/// item1, // Inline comment
+	/// // Not inline comment
+	/// item2,
+	/// ```
+	pub inline_trivia: ChildTrivia,
+}
+
+pub struct EndingComments {
+	/// If this child has two newlines above in source code, so it needs to have it in the output
+	pub should_start_with_newline: bool,
+	pub trivia: ChildTrivia,
+}
+impl EndingComments {
+	pub fn is_empty(&self) -> bool {
+		!self.should_start_with_newline && self.trivia.is_empty()
+	}
+	pub fn extract_trailing(&mut self) -> ChildTrivia {
+		mem::take(&mut self.trivia)
+	}
+}

--- /dev/null
+++ b/cmds/jrsonnet-fmt/src/comments.rs
@@ -0,0 +1,183 @@
+use dprint_core::formatting::PrintItems;
+use jrsonnet_rowan_parser::{nodes::TriviaKind, AstToken};
+
+use crate::{children::ChildTrivia, p, pi};
+
+pub enum CommentLocation {
+	/// Above local, field, other things
+	AboveItem,
+	/// After item
+	ItemInline,
+	/// After all items in object
+	EndOfItems,
+}
+
+#[must_use]
+pub fn format_comments(comments: &ChildTrivia, loc: CommentLocation) -> PrintItems {
+	let mut pi = p!(new:);
+
+	for c in comments {
+		let Ok(c) = c else {
+			let mut text = c.as_ref().unwrap_err() as &str;
+			while !text.is_empty() {
+				let pos = text.find(|c| c == '\n' || c == '\t').unwrap_or(text.len());
+				let sliced = &text[..pos];
+				p!(pi: string(sliced.to_string()));
+				text = &text[pos..];
+				if !text.is_empty() {
+					match text.as_bytes()[0] {
+						b'\n' => p!(pi: nl),
+						b'\t' => p!(pi: tab),
+						_ => unreachable!(),
+					}
+					text = &text[1..];
+				}
+			}
+			continue;
+		};
+		match c.kind() {
+			TriviaKind::Whitespace => {}
+			TriviaKind::MultiLineComment => {
+				let mut text = c
+					.text()
+					.strip_prefix("/*")
+					.expect("ml comment starts with /*")
+					.strip_suffix("*/")
+					.expect("ml comment ends with */");
+				// doc-style comment, /**
+				let doc = if text.starts_with('*') {
+					text = &text[1..];
+					true
+				} else {
+					false
+				};
+				// Is comment starts with text immediatly, i.e /*text
+				let mut immediate_start = true;
+				let mut lines = text
+					.split('\n')
+					.map(|l| l.trim_end().to_string())
+					.skip_while(|l| {
+						if l.is_empty() {
+							immediate_start = false;
+							true
+						} else {
+							false
+						}
+					})
+					.collect::<Vec<_>>();
+				while lines.last().map(|l| l.is_empty()).unwrap_or(false) {
+					lines.pop();
+				}
+				if lines.len() == 1 && !doc {
+					if matches!(loc, CommentLocation::ItemInline) {
+						p!(pi: str(" "));
+					}
+					p!(pi: str("/* ") string(lines[0].trim().to_string()) str(" */"))
+				} else if !lines.is_empty() {
+					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {
+						let offset = a
+							.bytes()
+							.zip(b.bytes())
+							.take_while(|(a, b)| a == b && (a.is_ascii_whitespace() || *a == b'*'))
+							.count();
+						&a[..offset]
+					}
+					// First line is not empty, extract ws prefix of it
+					let mut common_ws_padding = (if immediate_start && lines.len() > 1 {
+						common_ws_prefix(&lines[1], &lines[1])
+					} else {
+						common_ws_prefix(&lines[0], &lines[0])
+					})
+					.to_string();
+					for line in lines
+						.iter()
+						.skip(if immediate_start { 2 } else { 1 })
+						.filter(|l| !l.is_empty())
+					{
+						common_ws_padding = common_ws_prefix(&common_ws_padding, line).to_string();
+					}
+					for line in lines
+						.iter_mut()
+						.skip(if immediate_start { 1 } else { 0 })
+						.filter(|l| !l.is_empty())
+					{
+						*line = line
+							.strip_prefix(&common_ws_padding)
+							.expect("all non-empty lines start with this padding")
+							.to_string();
+					}
+
+					p!(pi: str("/*"));
+					if doc {
+						p!(pi: str("*"));
+					}
+					p!(pi: nl);
+					for mut line in lines {
+						if doc {
+							p!(pi: str(" *"));
+						}
+						if line.is_empty() {
+							p!(pi: nl);
+						} else {
+							if doc {
+								p!(pi: str(" "));
+							}
+							while let Some(new_line) = line.strip_prefix('\t') {
+								if doc {
+									p!(pi: str("    "));
+								} else {
+									p!(pi: tab);
+								}
+								line = new_line.to_string();
+							}
+							p!(pi: string(line.to_string()) nl)
+						}
+					}
+					if doc {
+						p!(pi: str(" "));
+					}
+					p!(pi: str("*/") nl)
+				}
+			}
+			// TODO: Keep common padding for multiple continous lines of single-line comments
+			// I.e
+			// ```
+			// #  Line1
+			// #    Line2
+			// ```
+			// Should be reformatted as
+			// ```
+			// # Line1
+			// #   Line2
+			// ```
+			// But currently comment formatter is not aware of continous comment lines, and reformats it as
+			// ```
+			// # Line1
+			// # Line2
+			// ```
+			TriviaKind::SingleLineHashComment => {
+				if matches!(loc, CommentLocation::ItemInline) {
+					p!(pi: str(" "))
+				}
+				p!(pi: str("# ") string(c.text().strip_prefix('#').expect("hash comment starts with #").trim().to_string()));
+				if !matches!(loc, CommentLocation::ItemInline) {
+					p!(pi: nl)
+				}
+			}
+			TriviaKind::SingleLineSlashComment => {
+				if matches!(loc, CommentLocation::ItemInline) {
+					p!(pi: str(" "))
+				}
+				p!(pi: str("// ") string(c.text().strip_prefix("//").expect("comment starts with //").trim().to_string()));
+				if !matches!(loc, CommentLocation::ItemInline) {
+					p!(pi: nl)
+				}
+			}
+			// Garbage in - garbage out
+			TriviaKind::ErrorCommentTooShort => p!(pi: str("/*/")),
+			TriviaKind::ErrorCommentUnterminated => p!(pi: string(c.text().to_string())),
+		}
+	}
+
+	pi
+}

--- /dev/null
+++ b/cmds/jrsonnet-fmt/src/main.rs
@@ -0,0 +1,804 @@
+use std::{
+	any::type_name,
+	fs,
+	io::{self, Write},
+	path::PathBuf,
+	process,
+};
+
+use children::{children_between, trivia_before};
+use clap::Parser;
+use dprint_core::formatting::{PrintItems, PrintOptions};
+use jrsonnet_rowan_parser::{
+	nodes::{
+		ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,
+		DestructRest, Expr, ExprBase, FieldName, ForSpec, IfSpec, ImportKind, Literal, Member,
+		Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Stmt, Suffix, Text,
+		UnaryOperator, Visibility,
+	},
+	AstNode, AstToken, SyntaxToken,
+};
+
+use crate::{
+	children::{trivia_after, trivia_between},
+	comments::{format_comments, CommentLocation},
+};
+
+mod children;
+mod comments;
+#[cfg(test)]
+mod tests;
+
+pub trait Printable {
+	fn print(&self) -> PrintItems;
+}
+
+macro_rules! pi {
+	(@i; $($t:tt)*) => {{
+		#[allow(unused_mut)]
+		let mut o = dprint_core::formatting::PrintItems::new();
+		pi!(@s; o: $($t)*);
+		o
+	}};
+	(@s; $o:ident: str($e:expr $(,)?) $($t:tt)*) => {{
+		$o.push_str($e);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: string($e:expr $(,)?) $($t:tt)*) => {{
+		$o.push_string($e);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: nl $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::NewLine);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: tab $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::Tab);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: >i $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::StartIndent);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: <i $($t:tt)*) => {{
+		$o.push_signal(dprint_core::formatting::Signal::FinishIndent);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: {$expr:expr} $($t:tt)*) => {{
+		$o.extend($expr.print());
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: items($expr:expr) $($t:tt)*) => {{
+		$o.extend($expr);
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: if ($e:expr)($($then:tt)*) $($t:tt)*) => {{
+		if $e {
+			pi!(@s; $o: $($then)*);
+		}
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $o:ident: ifelse ($e:expr)($($then:tt)*)($($else:tt)*) $($t:tt)*) => {{
+		if $e {
+			pi!(@s; $o: $($then)*);
+		} else {
+			pi!(@s; $o: $($else)*);
+		}
+		pi!(@s; $o: $($t)*);
+	}};
+	(@s; $i:ident:) => {}
+}
+macro_rules! p {
+	(new: $($t:tt)*) => {
+		pi!(@i; $($t)*)
+	};
+	($o:ident: $($t:tt)*) => {
+		pi!(@s; $o: $($t)*)
+	};
+}
+pub(crate) use p;
+pub(crate) use pi;
+
+impl<P> Printable for Option<P>
+where
+	P: Printable,
+{
+	fn print(&self) -> PrintItems {
+		if let Some(v) = self {
+			v.print()
+		} else {
+			p!(new: string(
+				format!(
+					"/*missing {}*/",
+					type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")
+				),
+			))
+		}
+	}
+}
+
+impl Printable for SyntaxToken {
+	fn print(&self) -> PrintItems {
+		p!(new: string(self.to_string()))
+	}
+}
+
+impl Printable for Text {
+	fn print(&self) -> PrintItems {
+		p!(new: string(format!("{}", self)))
+	}
+}
+impl Printable for Number {
+	fn print(&self) -> PrintItems {
+		p!(new: string(format!("{}", self)))
+	}
+}
+
+impl Printable for Name {
+	fn print(&self) -> PrintItems {
+		p!(new: {self.ident_lit()})
+	}
+}
+
+impl Printable for DestructRest {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new: str("..."));
+		if let Some(name) = self.into() {
+			p!(pi: {name});
+		}
+		pi
+	}
+}
+
+impl Printable for Destruct {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new:);
+		match self {
+			Destruct::DestructFull(f) => {
+				p!(pi: {f.name()})
+			}
+			Destruct::DestructSkip(_) => p!(pi: str("?")),
+			Destruct::DestructArray(a) => {
+				p!(pi: str("[") >i nl);
+				for el in a.destruct_array_parts() {
+					match el {
+						DestructArrayPart::DestructArrayElement(e) => {
+							p!(pi: {e.destruct()} str(",") nl)
+						}
+						DestructArrayPart::DestructRest(d) => {
+							p!(pi: {d} str(",") nl)
+						}
+					}
+				}
+				p!(pi: <i str("]"));
+			}
+			Destruct::DestructObject(o) => {
+				p!(pi: str("{") >i nl);
+				for item in o.destruct_object_fields() {
+					p!(pi: {item.field()});
+					if let Some(des) = item.destruct() {
+						p!(pi: str(": ") {des})
+					}
+					if let Some(def) = item.expr() {
+						p!(pi: str(" = ") {def});
+					}
+					p!(pi: str(",") nl);
+				}
+				if let Some(rest) = o.destruct_rest() {
+					p!(pi: {rest} nl)
+				}
+				p!(pi: <i str("}"));
+			}
+		}
+		pi
+	}
+}
+
+impl Printable for FieldName {
+	fn print(&self) -> PrintItems {
+		match self {
+			FieldName::FieldNameFixed(f) => {
+				if let Some(id) = f.id() {
+					p!(new: {id})
+				} else if let Some(str) = f.text() {
+					p!(new: {str})
+				} else {
+					p!(new: str("/*missing FieldName*/"))
+				}
+			}
+			FieldName::FieldNameDynamic(d) => {
+				p!(new: str("[") {d.expr()} str("]"))
+			}
+		}
+	}
+}
+
+impl Printable for Visibility {
+	fn print(&self) -> PrintItems {
+		p!(new: string(self.to_string()))
+	}
+}
+
+impl Printable for ObjLocal {
+	fn print(&self) -> PrintItems {
+		p!(new: str("local ") {self.bind()})
+	}
+}
+
+impl Printable for Assertion {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new: str("assert ") {self.condition()});
+		if self.colon_token().is_some() || self.message().is_some() {
+			p!(pi: str(": ") {self.message()})
+		}
+		pi
+	}
+}
+
+impl Printable for ParamsDesc {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new: str("(") >i nl);
+		for param in self.params() {
+			p!(pi: {param.destruct()});
+			if param.assign_token().is_some() || param.expr().is_some() {
+				p!(pi: str(" = ") {param.expr()})
+			}
+			p!(pi: str(",") nl)
+		}
+		p!(pi: <i str(")"));
+		pi
+	}
+}
+impl Printable for ArgsDesc {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new: str("(") >i nl);
+		for arg in self.args() {
+			if arg.name().is_some() || arg.assign_token().is_some() {
+				p!(pi: {arg.name()} str(" = "));
+			}
+			p!(pi: {arg.expr()} str(",") nl)
+		}
+		p!(pi: <i str(")"));
+		pi
+	}
+}
+impl Printable for SliceDesc {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new: str("["));
+		if self.from().is_some() {
+			p!(pi: {self.from()});
+		}
+		p!(pi: str(":"));
+		if self.end().is_some() {
+			p!(pi: {self.end().map(|e|e.expr())})
+		}
+		// Keep only one : in case if we don't need step
+		if self.step().is_some() {
+			p!(pi: str(":") {self.step().map(|e|e.expr())});
+		}
+		p!(pi: str("]"));
+		pi
+	}
+}
+
+impl Printable for Member {
+	fn print(&self) -> PrintItems {
+		match self {
+			Member::MemberBindStmt(b) => {
+				p!(new: {b.obj_local()})
+			}
+			Member::MemberAssertStmt(ass) => {
+				p!(new: {ass.assertion()})
+			}
+			Member::MemberFieldNormal(n) => {
+				p!(new: {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()})
+			}
+			Member::MemberFieldMethod(m) => {
+				p!(new: {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()})
+			}
+		}
+	}
+}
+
+impl Printable for ObjBody {
+	fn print(&self) -> PrintItems {
+		match self {
+			ObjBody::ObjBodyComp(l) => {
+				let (children, mut end_comments) = children_between::<Member>(
+					l.syntax().clone(),
+					l.l_brace_token().map(Into::into).as_ref(),
+					Some(
+						&(l.comp_specs()
+							.next()
+							.expect("at least one spec is defined")
+							.syntax()
+							.clone())
+						.into(),
+					),
+					None,
+				);
+				let trailing_for_comp = end_comments.extract_trailing();
+				let mut pi = p!(new: str("{") >i nl);
+				for mem in children.into_iter() {
+					if mem.should_start_with_newline {
+						p!(pi: nl);
+					}
+					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));
+					p!(pi: {mem.value} str(","));
+					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));
+					p!(pi: nl)
+				}
+
+				if end_comments.should_start_with_newline {
+					p!(pi: nl);
+				}
+				p!(pi: items(format_comments(&end_comments.trivia, CommentLocation::EndOfItems)));
+
+				let (compspecs, end_comments) = children_between::<CompSpec>(
+					l.syntax().clone(),
+					l.member_comps()
+						.last()
+						.map(|m| m.syntax().clone())
+						.map(Into::into)
+						.or_else(|| l.l_brace_token().map(Into::into))
+						.as_ref(),
+					l.r_brace_token().map(Into::into).as_ref(),
+					Some(trailing_for_comp),
+				);
+				for mem in compspecs.into_iter() {
+					if mem.should_start_with_newline {
+						p!(pi: nl);
+					}
+					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));
+					p!(pi: {mem.value});
+					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));
+				}
+				if end_comments.should_start_with_newline {
+					p!(pi: nl);
+				}
+				p!(pi: items(format_comments(&end_comments.trivia, CommentLocation::EndOfItems)));
+
+				p!(pi: nl <i str("}"));
+				pi
+			}
+			ObjBody::ObjBodyMemberList(l) => {
+				let (children, end_comments) = children_between::<Member>(
+					l.syntax().clone(),
+					l.l_brace_token().map(Into::into).as_ref(),
+					l.r_brace_token().map(Into::into).as_ref(),
+					None,
+				);
+				if children.is_empty() && end_comments.is_empty() {
+					return p!(new: str("{ }"));
+				}
+				let mut pi = p!(new: str("{") >i nl);
+				for mem in children.into_iter() {
+					if mem.should_start_with_newline {
+						p!(pi: nl);
+					}
+					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));
+					p!(pi: {mem.value} str(","));
+					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));
+					p!(pi: nl)
+				}
+
+				if end_comments.should_start_with_newline {
+					p!(pi: nl);
+				}
+				p!(pi: items(format_comments(&end_comments.trivia, CommentLocation::EndOfItems)));
+				p!(pi: <i str("}"));
+				pi
+			}
+		}
+	}
+}
+impl Printable for UnaryOperator {
+	fn print(&self) -> PrintItems {
+		p!(new: string(self.text().to_string()))
+	}
+}
+impl Printable for BinaryOperator {
+	fn print(&self) -> PrintItems {
+		p!(new: string(self.text().to_string()))
+	}
+}
+impl Printable for Bind {
+	fn print(&self) -> PrintItems {
+		match self {
+			Bind::BindDestruct(d) => {
+				p!(new: {d.into()} str(" = ") {d.value()})
+			}
+			Bind::BindFunction(f) => {
+				p!(new: {f.name()} {f.params()} str(" = ") {f.value()})
+			}
+		}
+	}
+}
+impl Printable for Literal {
+	fn print(&self) -> PrintItems {
+		p!(new: string(self.syntax().to_string()))
+	}
+}
+impl Printable for ImportKind {
+	fn print(&self) -> PrintItems {
+		p!(new: string(self.syntax().to_string()))
+	}
+}
+impl Printable for ForSpec {
+	fn print(&self) -> PrintItems {
+		p!(new: str("for ") {self.bind()} str(" in ") {self.expr()})
+	}
+}
+impl Printable for IfSpec {
+	fn print(&self) -> PrintItems {
+		p!(new: str("if ") {self.expr()})
+	}
+}
+impl Printable for CompSpec {
+	fn print(&self) -> PrintItems {
+		match self {
+			CompSpec::ForSpec(f) => f.print(),
+			CompSpec::IfSpec(i) => i.print(),
+		}
+	}
+}
+impl Printable for Expr {
+	fn print(&self) -> PrintItems {
+		let mut o = p!(new:);
+		let (stmts, ending) = children_between::<Stmt>(
+			self.syntax().clone(),
+			None,
+			self.expr_base()
+				.as_ref()
+				.map(ExprBase::syntax)
+				.cloned()
+				.map(Into::into)
+				.as_ref(),
+			None,
+		);
+		for stmt in stmts {
+			p!(o: {stmt.value});
+		}
+		p!(o: {self.expr_base()});
+		let (suffixes, ending) = children_between::<Suffix>(
+			self.syntax().clone(),
+			self.expr_base()
+				.as_ref()
+				.map(ExprBase::syntax)
+				.cloned()
+				.map(Into::into)
+				.as_ref(),
+			None,
+			None,
+		);
+		for suffix in suffixes {
+			p!(o: {suffix.value});
+		}
+		o
+	}
+}
+impl Printable for Suffix {
+	fn print(&self) -> PrintItems {
+		let mut o = p!(new:);
+		match self {
+			Suffix::SuffixIndex(i) => {
+				if i.question_mark_token().is_some() {
+					p!(o: str("?"));
+				}
+				p!(o: str(".") {i.index()});
+			}
+			Suffix::SuffixIndexExpr(e) => {
+				if e.question_mark_token().is_some() {
+					p!(o: str(".?"));
+				}
+				p!(o: str("[") {e.index()} str("]"))
+			}
+			Suffix::SuffixSlice(d) => {
+				p!(o: {d.slice_desc()})
+			}
+			Suffix::SuffixApply(a) => {
+				p!(o: {a.args_desc()})
+			}
+		}
+		o
+	}
+}
+impl Printable for Stmt {
+	fn print(&self) -> PrintItems {
+		match self {
+			Stmt::StmtLocal(l) => {
+				let mut pi = p!(new:);
+				let (binds, end_comments) = children_between::<Bind>(
+					l.syntax().clone(),
+					l.local_kw_token().map(Into::into).as_ref(),
+					l.semi_token().map(Into::into).as_ref(),
+					None,
+				);
+				if binds.len() == 1 {
+					let bind = &binds[0];
+					p!(pi: items(format_comments(&bind.before_trivia, CommentLocation::AboveItem)));
+					p!(pi: str("local ") {bind.value});
+				// TODO: keep end_comments, child.inline_trivia somehow, force multiple locals formatting in case of presence?
+				} else {
+					p!(pi: str("local") >i nl);
+					for bind in binds {
+						if bind.should_start_with_newline {
+							p!(pi: nl);
+						}
+						p!(pi: items(format_comments(&bind.before_trivia, CommentLocation::AboveItem)));
+						p!(pi: {bind.value} str(","));
+						p!(pi: items(format_comments(&bind.inline_trivia, CommentLocation::ItemInline)) nl);
+					}
+					if end_comments.should_start_with_newline {
+						p!(pi: nl)
+					}
+					p!(pi: items(format_comments(&end_comments.trivia, CommentLocation::EndOfItems)));
+					p!(pi: <i);
+				}
+				p!(pi: str(";") nl);
+				pi
+			}
+			Stmt::StmtAssert(a) => {
+				p!(new: {a.assertion()} str(";") nl)
+			}
+		}
+	}
+}
+impl Printable for ExprBase {
+	fn print(&self) -> PrintItems {
+		match self {
+			Self::ExprBinary(b) => {
+				p!(new: {b.lhs_work()} str(" ") {b.binary_operator()} str(" ") {b.rhs_work()})
+			}
+			Self::ExprUnary(u) => p!(new: {u.unary_operator()} {u.rhs()}),
+			// Self::ExprSlice(s) => {
+			// 	p!(new: {s.expr()} {s.slice_desc()})
+			// }
+			// Self::ExprIndex(i) => {
+			// 	p!(new: {i.expr()} str(".") {i.index()})
+			// }
+			// Self::ExprIndexExpr(i) => p!(new: {i.base()} str("[") {i.index()} str("]")),
+			// Self::ExprApply(a) => {
+			// 	let mut pi = p!(new: {a.expr()} {a.args_desc()});
+			// 	if a.tailstrict_kw_token().is_some() {
+			// 		p!(pi: str(" tailstrict"));
+			// 	}
+			// 	pi
+			// }
+			Self::ExprObjExtend(ex) => {
+				p!(new: {ex.lhs_work()} str(" ") {ex.rhs_work()})
+			}
+			Self::ExprParened(p) => {
+				p!(new: str("(") {p.expr()} str(")"))
+			}
+			Self::ExprString(s) => p!(new: {s.text()}),
+			Self::ExprNumber(n) => p!(new: {n.number()}),
+			Self::ExprArray(a) => {
+				let mut pi = p!(new: str("[") >i nl);
+				for el in a.exprs() {
+					p!(pi: {el} str(",") nl);
+				}
+				p!(pi: <i str("]"));
+				pi
+			}
+			Self::ExprObject(obj) => {
+				p!(new: {obj.obj_body()})
+			}
+			Self::ExprArrayComp(arr) => {
+				let mut pi = p!(new: str("[") {arr.expr()});
+				for spec in arr.comp_specs() {
+					p!(pi: str(" ") {spec});
+				}
+				p!(pi: str("]"));
+				pi
+			}
+			Self::ExprImport(v) => {
+				p!(new: {v.import_kind()} str(" ") {v.text()})
+			}
+			Self::ExprVar(n) => p!(new: {n.name()}),
+			// Self::ExprLocal(l) => {
+			// }
+			Self::ExprIfThenElse(ite) => {
+				let mut pi =
+					p!(new: str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});
+				if ite.else_kw_token().is_some() || ite.else_().is_some() {
+					p!(pi: str(" else ") {ite.else_().map(|t| t.expr())})
+				}
+				pi
+			}
+			Self::ExprFunction(f) => p!(new: str("function") {f.params_desc()} nl {f.expr()}),
+			// Self::ExprAssert(a) => p!(new: {a.assertion()} str("; ") {a.expr()}),
+			Self::ExprError(e) => p!(new: str("error ") {e.expr()}),
+			Self::ExprLiteral(l) => {
+				p!(new: {l.literal()})
+			}
+		}
+	}
+}
+
+impl Printable for SourceFile {
+	fn print(&self) -> PrintItems {
+		let mut pi = p!(new:);
+		let before = trivia_before(
+			self.syntax().clone(),
+			self.expr()
+				.map(|e| e.syntax().clone())
+				.map(Into::into)
+				.as_ref(),
+		);
+		let after = trivia_after(
+			self.syntax().clone(),
+			self.expr()
+				.map(|e| e.syntax().clone())
+				.map(Into::into)
+				.as_ref(),
+		);
+		p!(pi: items(format_comments(&before, CommentLocation::AboveItem)));
+		p!(pi: {self.expr()} nl);
+		p!(pi: items(format_comments(&after, CommentLocation::EndOfItems)));
+		pi
+	}
+}
+
+struct FormatOptions {
+	// 0 for hard tabs
+	indent: u8,
+}
+fn format(input: &str, opts: &FormatOptions) -> Option<String> {
+	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);
+	if !errors.is_empty() {
+		let mut builder = ass_stroke::SnippetBuilder::new(input);
+		for error in errors {
+			builder
+				.error(ass_stroke::Text::single(
+					format!("{:?}", error.error).chars(),
+					Default::default(),
+				))
+				.range(
+					error.range.start().into()
+						..=(usize::from(error.range.end()) - 1).max(error.range.start().into()),
+				)
+				.build();
+		}
+		let snippet = builder.build();
+		let ansi = ass_stroke::source_to_ansi(&snippet);
+		eprintln!("{ansi}");
+		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip
+		// ERROR rowan nodes.
+		// Recovery needs to be enabled for LSP, though.
+		//
+		// TODO: Verify how formatter interacts in cases of missing positional values, i.e `if cond then /*missing Expr*/ else residual`.
+		return None;
+	}
+	Some(dprint_core::formatting::format(
+		|| parsed.print(),
+		PrintOptions {
+			indent_width: if opts.indent == 0 {
+				// Reasonable max length for both 2 and 4 space sized tabs.
+				3
+			} else {
+				opts.indent
+			},
+			max_width: 100,
+			use_tabs: opts.indent == 0,
+			new_line_text: "\n",
+		},
+	))
+}
+
+#[derive(Parser)]
+struct Opts {
+	/// Treat input as code, reformat it instead of reading file.
+	#[clap(long, short = 'e')]
+	exec: bool,
+	/// Path to be reformatted if `--exec` if unset, otherwise code itself.
+	input: String,
+	/// Replace code with formatted in-place, instead of printing it to stdout.
+	/// Only applicable if `--exec` is unset.
+	#[clap(long, short = 'i')]
+	in_place: bool,
+
+	/// Exit with error if formatted does not match input
+	#[arg(long)]
+	test: bool,
+	/// Number of spaces to indent with
+	///
+	/// 0 for guess from input (default), and use hard tabs if unable to guess.
+	#[arg(long, default_value = "0")]
+	indent: u8,
+	/// Force hard tab for indentation
+	#[arg(long)]
+	hard_tabs: bool,
+
+	/// Debug option: how many times to call reformatting in case of unstable dprint output resolution.
+	///
+	/// 0 for not retrying to reformat.
+	#[arg(long, default_value = "0")]
+	conv_limit: usize,
+}
+
+#[derive(thiserror::Error, Debug)]
+enum Error {
+	#[error("--in-place is incompatible with --exec")]
+	InPlaceExec,
+	#[error("io: {0}")]
+	Io(#[from] io::Error),
+	#[error("persist: {0}")]
+	Persist(#[from] tempfile::PersistError),
+	#[error("parsing failed, refusing to reformat corrupted input")]
+	ParseError,
+}
+
+fn main_result() -> Result<(), Error> {
+	eprintln!("jrsonnet-fmt is a prototype of a jsonnet code formatter, do not expect it to produce meaningful results right now.");
+	eprintln!("It is not expected for its output to match other implementations, it will be completly separate implementation with maybe different name.");
+	let mut opts = Opts::parse();
+	let input = if opts.exec {
+		if opts.in_place {
+			return Err(Error::InPlaceExec);
+		}
+		opts.input.clone()
+	} else {
+		fs::read_to_string(&opts.input)?
+	};
+
+	if opts.indent == 0 {
+		// Sane default.
+		// TODO: Implement actual guessing.
+		opts.hard_tabs = true;
+	}
+
+	let mut iteration = 0;
+	let mut formatted = input.clone();
+	let mut tmp;
+	// https://github.com/dprint/dprint/pull/423
+	loop {
+		let Some(reformatted) = format(
+			&formatted,
+			&FormatOptions {
+				indent: if opts.indent == 0 || opts.hard_tabs {
+					0
+				} else {
+					opts.indent
+				},
+			},
+		) else {
+			return Err(Error::ParseError);
+		};
+		tmp = reformatted.trim().to_owned();
+		if formatted == tmp {
+			break;
+		}
+		formatted = tmp;
+		if opts.conv_limit == 0 {
+			break;
+		}
+		iteration += 1;
+		if iteration > opts.conv_limit {
+			panic!("formatting not converged");
+		}
+	}
+	formatted.push('\n');
+	if opts.test && formatted != input {
+		process::exit(1);
+	}
+	if opts.in_place {
+		let path = PathBuf::from(opts.input);
+		let mut temp = tempfile::NamedTempFile::new_in(path.parent().expect(
+			"not failed during read, this path is not a directory, and there is a parent",
+		))?;
+		temp.write_all(formatted.as_bytes())?;
+		temp.flush()?;
+		temp.persist(&path)?;
+	} else {
+		print!("{formatted}")
+	}
+	Ok(())
+}
+
+fn main() {
+	if let Err(e) = main_result() {
+		eprintln!("{e}");
+		process::exit(1);
+	}
+}

--- /dev/null
+++ b/cmds/jrsonnet-fmt/src/snapshots/jrsonnet_fmt__tests__complex_comments_snapshot.snap
@@ -0,0 +1,53 @@
+---
+source: cmds/jrsonnet-fmt/src/tests.rs
+expression: "reformat(indoc!(\"{\n\t\t  comments: {\n\t\t\t_: '',\n\t\t\t//     Plain comment\n\t\t\ta: '',\n\n\t\t\t#    Plain comment with empty line before\n\t\t\tb: '',\n\t\t\t/*Single-line multiline comment\n\n\t\t\t*/\n\t\t\tc: '',\n\n\t\t\t/**Single-line multiline doc comment\n\n\t\t\t*/\n\t\t\tc: '',\n\n\t\t\t/**Multiline doc\n\t\t\tComment\n\t\t\t*/\n\t\t\tc: '',\n\n\t\t\t/*\n\n\tMulti-line\n\n\tcomment\n\t\t\t*/\n\t\t\td: '',\n\n\t\t\te: '', // Inline comment\n\n\t\t\tk: '',\n\n\t\t\t// Text after everything\n\t\t  },\n\t\t  comments2: {\n\t\t\tk: '',\n\t\t\t// Text after everything, but no newline above\n\t\t  },\n          spacing: {\n            a: '',\n\n            b: '',\n          },\n          noSpacing: {\n            a: '',\n            b: '',\n          },\n        }\"))"
+---
+{
+  comments: {
+    _: '',
+    // Plain comment
+    a: '',
+
+    # Plain comment with empty line before
+    b: '',
+    /* Single-line multiline comment */
+    c: '',
+
+    /**
+     * Single-line multiline doc comment
+     */
+    c: '',
+
+    /**
+     * Multiline doc
+     * Comment
+     */
+    c: '',
+
+    /*
+    Multi-line
+
+    comment
+    */
+    d: '',
+
+    e: '', // Inline comment
+
+    k: '',
+
+    // Text after everything
+  },
+  comments2: {
+    k: '',
+    // Text after everything, but no newline above
+  },
+  spacing: {
+    a: '',
+
+    b: '',
+  },
+  noSpacing: {
+    a: '',
+    b: '',
+  },
+}

--- /dev/null
+++ b/cmds/jrsonnet-fmt/src/tests.rs
@@ -0,0 +1,124 @@
+use dprint_core::formatting::PrintOptions;
+use indoc::indoc;
+
+use crate::Printable;
+
+fn reformat(input: &str) -> String {
+	let (source, _) = jrsonnet_rowan_parser::parse(input);
+
+	dprint_core::formatting::format(
+		|| source.print(),
+		PrintOptions {
+			indent_width: 2,
+			max_width: 100,
+			use_tabs: false,
+			new_line_text: "\n",
+		},
+	)
+}
+
+macro_rules! assert_formatted {
+	($input:literal, $output:literal) => {
+		let formatted = reformat(indoc!($input));
+		let mut expected = indoc!($output).to_owned();
+		expected.push('\n');
+		if formatted != expected {
+			panic!(
+				"bad formatting, expected\n```\n{formatted}\n```\nto be equal to\n```\n{expected}\n```",
+			)
+		}
+	};
+}
+
+#[test]
+fn padding_stripped_for_multiline_comment() {
+	assert_formatted!(
+		"{
+            /*
+                Hello
+                    World
+            */
+            _: null,
+        }",
+		"{
+          /*
+          Hello
+              World
+          */
+          _: null,
+        }"
+	);
+}
+
+#[test]
+fn last_comment_respects_spacing_with_inline_comment_above() {
+	assert_formatted!(
+		"{
+			a: '', // Inline
+
+			// Comment
+        }",
+		"{
+		  a: '', // Inline
+
+		  // Comment
+		}"
+	);
+}
+
+#[test]
+fn complex_comments_snapshot() {
+	insta::assert_display_snapshot!(reformat(indoc!(
+		"{
+		  comments: {
+			_: '',
+			//     Plain comment
+			a: '',
+
+			#    Plain comment with empty line before
+			b: '',
+			/*Single-line multiline comment
+
+			*/
+			c: '',
+
+			/**Single-line multiline doc comment
+
+			*/
+			c: '',
+
+			/**Multiline doc
+			Comment
+			*/
+			c: '',
+
+			/*
+
+	Multi-line
+
+	comment
+			*/
+			d: '',
+
+			e: '', // Inline comment
+
+			k: '',
+
+			// Text after everything
+		  },
+		  comments2: {
+			k: '',
+			// Text after everything, but no newline above
+		  },
+          spacing: {
+            a: '',
+
+            b: '',
+          },
+          noSpacing: {
+            a: '',
+            b: '',
+          },
+        }"
+	)))
+}

--- /dev/null
+++ b/cmds/jrsonnet-lsp/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "jrsonnet-lsp"
+version.workspace = true
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.48"
+jrsonnet-evaluator.workspace = true
+jrsonnet-rowan-parser.workspace = true
+lsp-server = "0.6.0"
+lsp-types = "0.93.0"
+serde = "1.0.130"
+serde_json = "1.0.71"

--- /dev/null
+++ b/cmds/jrsonnet-lsp/src/main.rs
@@ -0,0 +1,188 @@
+use std::{fs::File, io::Write, path::PathBuf, str::FromStr};
+
+use lsp_server::{Connection, ErrorCode, Message, Request, RequestId, Response};
+use lsp_types::{
+	notification::{DidChangeTextDocument, DidOpenTextDocument, Notification},
+	request::{DocumentLinkRequest, HoverRequest},
+	CompletionOptions, DidChangeTextDocumentParams, DidOpenTextDocumentParams, DocumentLink,
+	DocumentLinkOptions, ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind,
+	TextDocumentSyncOptions, Url, WorkDoneProgressOptions,
+};
+
+fn main() {
+	let mut log = File::create("test").unwrap();
+	writeln!(log, "start").unwrap();
+	let (connection, io_threads) = Connection::stdio();
+	let capabilities = serde_json::to_value(&ServerCapabilities {
+		completion_provider: Some(CompletionOptions::default()),
+		definition_provider: Some(lsp_types::OneOf::Left(true)),
+		document_link_provider: Some(DocumentLinkOptions {
+			resolve_provider: Some(false),
+			work_done_progress_options: WorkDoneProgressOptions::default(),
+		}),
+		hover_provider: Some(lsp_types::HoverProviderCapability::Simple(true)),
+		text_document_sync: Some(TextDocumentSyncCapability::Options(
+			TextDocumentSyncOptions {
+				change: Some(TextDocumentSyncKind::FULL),
+				open_close: Some(true),
+				..TextDocumentSyncOptions::default()
+			},
+		)),
+		..ServerCapabilities::default()
+	})
+	.expect("failed to convert capabilities to json");
+
+	connection
+		.initialize(capabilities)
+		.expect("failed to initialize connection");
+
+	writeln!(log, "initialized").unwrap();
+
+	main_loop(&mut log, &connection).expect("main loop failed");
+
+	io_threads.join().expect("failed to join io_threads");
+}
+fn main_loop(log: &mut File, connection: &Connection) -> anyhow::Result<()> {
+	// let mut es = EvaluationState::default();
+	// es.set_import_resolver(Box::new(FileImportResolver::default()));
+
+	let reply = |response: Response| {
+		connection
+			.sender
+			.send(Message::Response(response))
+			.expect("failed to respond");
+	};
+
+	for msg in &connection.receiver {
+		match msg {
+			Message::Response(_) => (),
+			Message::Request(req) => {
+				if connection.handle_shutdown(&req)? {
+					return Ok(());
+				}
+				if let Some((id, params)) = cast::<DocumentLinkRequest>(&req) {
+					reply(Response::new_ok(id, <Vec<DocumentLink>>::new()));
+				} else if let Some((id, params)) = cast::<HoverRequest>(&req) {
+					let pos = params
+						.text_document_position_params
+						.text_document
+						.uri
+						.path();
+					let buf = PathBuf::from_str(pos).unwrap();
+				// let pos = es
+				// 	.map_from_source_location(
+				// 		&buf,
+				// 		params.text_document_position_params.position.line as usize + 1,
+				// 		params.text_document_position_params.position.character as usize + 1,
+				// 	)
+				// 	.unwrap();
+				// let el = ExprLocation(buf.clone().into(), pos as usize, pos as usize);
+				// let es2 = es.clone();
+				// reply(Response::new_ok(
+				// 	id,
+				// 	Some(Hover {
+				// 		range: None,
+				// 		contents: HoverContents::Markup(MarkupContent {
+				// 			kind: MarkupKind::Markdown,
+				// 			value: es
+				// 				.run_in_state_with_breakpoint(el, move || {
+				// 					es2.reset_evaluation_state(&buf);
+				// 					es2.import_file(&PathBuf::new(), &buf)?
+				// 						.to_string()
+				// 						.map(|_| ())
+				// 				})
+				// 				.unwrap()
+				// 				.unwrap_or_else(|| Val::Null)
+				// 				.value_type()
+				// 				.to_string(),
+				// 		}),
+				// 	}),
+				// ));
+				} else {
+					reply(Response::new_err(
+						req.id,
+						ErrorCode::MethodNotFound as i32,
+						format!("unrecognized request {}", req.method),
+					))
+				}
+				/*
+				if let Some((id, params)) = cast::<DocumentLinkRequest>(&req) {
+					 let links = handle_links(&files, params).unwrap_or_default();
+					 reply(Response::new_ok(id, links));
+				} else if let Some((id, params)) = cast::<GotoDefinition>(&req) {
+					 if let Some(loc) = handle_goto(&files, params) {
+						  reply(Response::new_ok(id, loc))
+					 } else {
+						  reply(Response::new_ok(id, ()))
+					 }
+				} else if let Some((id, params)) = cast::<HoverRequest>(&req) {
+					 match handle_hover(&files, params) {
+						  Some((range, markdown)) => {
+								reply(Response::new_ok(
+									 id,
+									 Hover {
+										  contents: HoverContents::Markup(MarkupContent {
+												kind: MarkupKind::Markdown,
+												value: markdown,
+										  }),
+										  range,
+									 },
+								));
+						  }
+						  None => {
+								reply(Response::new_ok(id, ()));
+						  }
+					 }
+				} else if let Some((id, params)) = cast::<Completion>(&req) {
+					 let completions = handle_completion(&files, params.text_document_position)
+						  .unwrap_or_default();
+					 reply(Response::new_ok(id, completions));
+				} else
+				*/
+			}
+			Message::Notification(req) => {
+				let mut handle = |text: String, uri: Url| {
+					writeln!(log, "updated file: {:?}", uri).unwrap();
+					let path = match PathBuf::from_str(uri.path()) {
+						Ok(x) => x,
+						Err(_) => return,
+					};
+					let (ast, errors) = jrsonnet_rowan_parser::parse(&text);
+					// es.add_parsed_file(path.into(), text.into(), parsed)
+					// 	.unwrap();
+					writeln!(log, "parsed: {:?}", uri).unwrap();
+				};
+
+				match &*req.method {
+					DidOpenTextDocument::METHOD => {
+						let params: DidOpenTextDocumentParams =
+							match serde_json::from_value(req.params) {
+								Ok(x) => x,
+								Err(_) => continue,
+							};
+						handle(params.text_document.text, params.text_document.uri);
+					}
+					DidChangeTextDocument::METHOD => {
+						let params: DidChangeTextDocumentParams =
+							match serde_json::from_value(req.params) {
+								Ok(x) => x,
+								Err(_) => continue,
+							};
+						for change in params.content_changes.into_iter() {
+							handle(change.text, params.text_document.uri.clone());
+						}
+					}
+					_ => continue,
+				}
+			}
+		}
+	}
+	Ok(())
+}
+fn cast<R>(req: &Request) -> Option<(RequestId, R::Params)>
+where
+	R: lsp_types::request::Request,
+	R::Params: serde::de::DeserializeOwned,
+{
+	req.clone().extract(R::METHOD).ok()
+}

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "jrsonnet-rowan-parser"
+version.workspace = true
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0"
+backtrace = "0.3.63"
+drop_bomb = "0.1.5"
+indoc = "1.0"
+logos = "0.12"
+miette = { version = "5.5.0", features = ["fancy"] }
+rowan = "0.15"
+text-size = "1.1"
+thiserror = "1.0"
+
+[dev-dependencies]
+backtrace = "0.3.63"
+indoc = "1.0"
+insta = "1.15"
+anyhow = "1.0"

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/jsonnet.ungram
@@ -0,0 +1,355 @@
+// This file describes structure of jsonnet source code
+// It is also used to generate files in src/generated
+
+// Token names ending with `!` are considered meta, and handled specifically
+
+SourceFile = Expr
+
+SuffixIndex =
+    '?'?
+    '.'
+    index:Name
+SuffixIndexExpr =
+    ('?' '.')?
+    '['
+    index:Expr
+    ']'
+SuffixSlice =
+    SliceDesc
+SuffixApply =
+    ArgsDesc
+    'tailstrict'?
+Suffix =
+    SuffixIndex
+|   SuffixIndexExpr
+|   SuffixSlice
+|   SuffixApply
+
+StmtLocal =
+    'local'
+    (Bind (',' Bind)* ','?)
+    ';'
+StmtAssert =
+    Assertion
+    ';'
+Stmt =
+    StmtLocal
+|   StmtAssert
+
+ExprBinary =
+    lhs:Expr
+    BinaryOperator
+    rhs:Expr
+ExprUnary =
+    UnaryOperator
+    rhs:Expr
+ExprObjExtend =
+    Expr
+    Expr
+ExprParened =
+    '('
+    Expr
+    ')'
+
+ExprLiteral =
+    Literal
+ExprString =
+    Text
+ExprNumber =
+    Number
+ExprArray =
+    '['
+    (Expr (',' Expr)* ','?)?
+    ']'
+ExprObject =
+    ObjBody
+ExprArrayComp =
+    '['
+    Expr
+    ','?
+    CompSpec*
+    ']'
+
+ExprImport =
+    ImportKind Text
+
+ImportKind =
+    'importstr'
+|   'importbin'
+|   'import'
+
+ExprVar =
+    name:Name
+
+ExprIfThenElse =
+    'if'
+    cond:Expr
+    'then'
+    then:TrueExpr
+    ('else' else_:FalseExpr)?
+
+ExprFunction =
+    'function'
+    '('
+    ParamsDesc
+    ')'
+    Expr
+ExprError =
+    'error'
+    Expr
+
+Expr =
+    Stmt*
+    ExprBase
+    Suffix*
+
+ExprBase =
+    ExprBinary
+|   ExprUnary
+|   ExprObjExtend
+|   ExprParened
+|   ExprString
+|   ExprNumber
+|   ExprLiteral
+|   ExprArray
+|   ExprObject
+|   ExprArrayComp
+|   ExprImport
+|   ExprVar
+|   ExprIfThenElse
+|   ExprFunction
+|   ExprError
+
+BinaryOperator =
+    '||' | '??' | '&&'
+|   '|' | '^' | '&'
+|   '==' | '!=' | '<' | '>' | '<=' | '>=' | 'in'
+|   '<<' | '>>'
+|   '+' | '-'
+|   '*' | '/' | '%'
+|   'META_OBJECT_APPLY!'
+|   'ERROR_NO_OPERATOR!'
+
+UnaryOperator =
+    '-' | '!' | '~'
+
+SliceDescEnd=Expr
+SliceDescStep=Expr
+SliceDesc =
+    '['
+    from:Expr?
+    ':'
+    (
+        end:SliceDescEnd?
+        (
+            ':'
+            step:SliceDescStep?
+        )?
+    )?
+    ']'
+
+Name =
+    'LIT_IDENT!'
+
+ArgsDesc =
+    '('
+    (Arg (',' Arg)* ','?)?
+    ')'
+Arg =
+    (name:Name '=')? Expr
+
+ObjBodyComp =
+    '{'
+    (MemberComp (',' MemberComp)* ','?)?
+    CompSpec*
+    '}'
+ObjBodyMemberList =
+    '{'
+    (Member (',' Member)* ','?)?
+    '}'
+ObjBody =
+    ObjBodyComp
+|   ObjBodyMemberList
+
+MemberBindStmt = ObjLocal
+MemberAssertStmt = Assertion
+MemberFieldNormal =
+    FieldName
+    '+'?
+    Visibility
+    Expr
+MemberFieldMethod =
+    FieldName
+    ParamsDesc
+    Visibility
+    Expr
+MemberComp =
+    MemberBindStmt
+|    MemberFieldNormal
+|   MemberFieldMethod
+Member =
+    MemberBindStmt
+|   MemberAssertStmt
+|   MemberFieldNormal
+|   MemberFieldMethod
+
+ObjLocal =
+    'local'
+    Bind
+
+FieldNameFixed =
+    id:Name
+|   Text
+FieldNameDynamic =
+    '['
+    Expr
+    ']'
+FieldName =
+    FieldNameFixed
+|   FieldNameDynamic
+
+Visibility =
+    ':::'
+|   '::'
+|   ':'
+
+Literal =
+    'null'
+|   'true'
+|   'false'
+|   'self'
+|   '$'
+|   'super'
+
+Text =
+    'LIT_STRING_DOUBLE!'
+|   'ERROR_STRING_DOUBLE_UNTERMINATED!'
+|   'LIT_STRING_SINGLE!'
+|   'ERROR_STRING_SINGLE_UNTERMINATED!'
+|   'LIT_STRING_DOUBLE_VERBATIM!'
+|   'ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED!'
+|   'LIT_STRING_SINGLE_VERBATIM!'
+|   'ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED!'
+|   'ERROR_STRING_VERBATIM_MISSING_QUOTES!'
+|   'LIT_STRING_BLOCK!'
+|   'ERROR_STRING_BLOCK_UNEXPECTED_END!'
+|   'ERROR_STRING_BLOCK_MISSING_NEW_LINE!'
+|   'ERROR_STRING_BLOCK_MISSING_TERMINATION!'
+|   'ERROR_STRING_BLOCK_MISSING_INDENT!'
+
+Number =
+    'LIT_FLOAT!'
+|   'ERROR_FLOAT_JUNK_AFTER_POINT!'
+|   'ERROR_FLOAT_JUNK_AFTER_EXPONENT!'
+|   'ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN!'
+
+ForSpec =
+    'for'
+    bind:Destruct
+    'in'
+    Expr
+IfSpec =
+    'if'
+    Expr
+CompSpec =
+    ForSpec
+|   IfSpec
+
+BindDestruct =
+    into:Destruct
+    '='
+    value:Expr
+BindFunction =
+    name:Name
+    params:ParamsDesc
+    '='
+    value:Expr
+Bind =
+    BindDestruct
+|   BindFunction
+
+ParamsDesc =
+    '('
+    (Param (',' Param)* ','?)?
+    ')'
+Param =
+    Destruct
+    (
+        '='
+        Expr
+    )?
+
+Assertion =
+    'assert'
+    condition:Expr
+    (
+        ':'
+        message:Expr
+    )?
+
+DestructFull =
+    Name
+DestructSkip =
+    '?'
+DestructArray =
+    '['
+    (
+        DestructArrayPart
+        (',' DestructArrayPart)*
+        ','?
+    )?
+    ']'
+DestructObject =
+    '{'
+    (
+        DestructObjectField
+        (',' DestructObjectField)*
+        ','?
+    )?
+    DestructRest?
+    ','?
+    '}'
+Destruct =
+    DestructFull
+|   DestructSkip
+|   DestructArray
+|   DestructObject
+
+DestructArrayElement =
+    Destruct
+DestructArrayPart =
+    DestructArrayElement
+|   DestructRest
+
+DestructRest =
+    '...'
+    into:Name?
+
+DestructObjectField =
+    field:Name
+    (
+        ':'
+        Destruct
+    )?
+    (
+        '='
+        Expr
+    )?
+
+// Aliases used to resolve node type conflicts
+TrueExpr=Expr
+FalseExpr=Expr
+
+// Trivia - tokens which will be implicitly skipped for parser
+Trivia =
+    'LIT_WHITESPACE!'
+|   'LIT_MULTI_LINE_COMMENT!'
+|   'ERROR_COMMENT_TOO_SHORT!'
+|   'ERROR_COMMENT_UNTERMINATED!'
+|   'LIT_SINGLE_LINE_HASH_COMMENT!'
+|   'LIT_SINGLE_LINE_SLASH_COMMENT!'
+
+CustomError =
+    'ERROR_MISSING_TOKEN!'
+|   'ERROR_UNEXPECTED_TOKEN!'
+|   'ERROR_CUSTOM!'

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/ast.rs
@@ -0,0 +1,95 @@
+use std::marker::PhantomData;
+
+use crate::{SyntaxKind, SyntaxNode, SyntaxNodeChildren, SyntaxToken};
+
+/// The main trait to go from untyped `SyntaxNode`  to a typed ast. The
+/// conversion itself has zero runtime cost: ast and syntax nodes have exactly
+/// the same representation: a pointer to the tree root and a pointer to the
+/// node itself.
+pub trait AstNode {
+	fn can_cast(kind: SyntaxKind) -> bool
+	where
+		Self: Sized;
+
+	fn cast(syntax: SyntaxNode) -> Option<Self>
+	where
+		Self: Sized;
+
+	fn syntax(&self) -> &SyntaxNode;
+	fn clone_for_update(&self) -> Self
+	where
+		Self: Sized,
+	{
+		Self::cast(self.syntax().clone_for_update()).unwrap()
+	}
+	fn clone_subtree(&self) -> Self
+	where
+		Self: Sized,
+	{
+		Self::cast(self.syntax().clone_subtree()).unwrap()
+	}
+}
+
+/// Like `AstNode`, but wraps tokens rather than interior nodes.
+pub trait AstToken {
+	fn can_cast(token: SyntaxKind) -> bool
+	where
+		Self: Sized;
+
+	fn cast(syntax: SyntaxToken) -> Option<Self>
+	where
+		Self: Sized;
+
+	fn syntax(&self) -> &SyntaxToken;
+
+	fn text(&self) -> &str {
+		self.syntax().text()
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct AstChildren<N> {
+	inner: SyntaxNodeChildren,
+	ph: PhantomData<N>,
+}
+
+impl<N> AstChildren<N> {
+	fn new(parent: &SyntaxNode) -> Self {
+		AstChildren {
+			inner: parent.children(),
+			ph: PhantomData,
+		}
+	}
+}
+
+impl<N: AstNode> Iterator for AstChildren<N> {
+	type Item = N;
+	fn next(&mut self) -> Option<N> {
+		self.inner.find_map(N::cast)
+	}
+}
+
+pub mod support {
+	use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};
+
+	pub fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
+		parent.children().find_map(N::cast)
+	}
+	pub fn token_child<N: AstToken>(parent: &SyntaxNode) -> Option<N> {
+		parent.children_with_tokens().find_map(|n| match n {
+			rowan::NodeOrToken::Node(_) => None,
+			rowan::NodeOrToken::Token(t) => N::cast(t),
+		})
+	}
+
+	pub fn children<N: AstNode>(parent: &SyntaxNode) -> AstChildren<N> {
+		AstChildren::new(parent)
+	}
+
+	pub fn token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
+		parent
+			.children_with_tokens()
+			.filter_map(|it| it.into_token())
+			.find(|it| it.kind() == kind)
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/event.rs
@@ -0,0 +1,204 @@
+use std::{mem, num::NonZeroUsize};
+
+use rowan::{GreenNodeBuilder, Language, TextRange, TextSize};
+
+use crate::{
+	lex::Lexeme,
+	nodes::Trivia,
+	parser::{LocatedSyntaxError, Parse, SyntaxError},
+	AstToken, JsonnetLanguage, SyntaxKind,
+};
+
+#[derive(Clone, Debug)]
+pub enum Event {
+	/// Used for unfinished markers
+	Pending,
+	/// After marker is completed, Pending event is replaced with Start
+	Start {
+		kind: SyntaxKind,
+		/// If marker is preceded or wrapped - instead of reordering events, we
+		/// insert start event in the end of events Vec instead, and store relative offset to this event here
+		forward_parent: Option<NonZeroUsize>,
+	},
+	/// Eat token
+	Token { kind: SyntaxKind },
+	/// Push token, but do not eat anything,
+	VirtualToken { kind: SyntaxKind },
+	/// Position of finished node
+	Finish {
+		/// Same as forward_parent of Start, but for wrapping
+		wrapper: Option<NonZeroUsize>,
+		error: Option<Box<SyntaxError>>,
+	},
+	/// Used for dropped markers and other things
+	Noop,
+}
+
+pub(super) struct Sink<'i> {
+	pub builder: GreenNodeBuilder<'static>,
+	lexemes: &'i [Lexeme<'i>],
+	offset: usize,
+	events: Vec<Event>,
+	pub errors: Vec<LocatedSyntaxError>,
+}
+
+impl<'i> Sink<'i> {
+	pub(super) fn new(events: Vec<Event>, lexemes: &'i [Lexeme<'i>]) -> Self {
+		Self {
+			builder: GreenNodeBuilder::new(),
+			lexemes,
+			offset: 0,
+			events,
+			errors: vec![],
+		}
+	}
+
+	fn text_offset(&self) -> TextSize {
+		if self.offset == 0 {
+			return 0.into();
+		};
+		if let Some(lex) = self.lexemes.get(self.offset) {
+			lex.range.start()
+		} else if let Some(lex) = self.lexemes.get(self.offset - 1) {
+			lex.range.end()
+		} else {
+			panic!("hard oob")
+		}
+	}
+
+	pub(super) fn finish(mut self) -> Parse {
+		let mut eat_start_whitespace = false;
+		let mut depth = 0;
+		let mut error_starts_at = Vec::new();
+		for idx in 0..self.events.len() {
+			match mem::replace(&mut self.events[idx], Event::Noop) {
+				Event::Start {
+					kind,
+					forward_parent,
+				} => {
+					if depth != 0 {
+						self.skip_whitespace();
+					}
+					let mut kinds = vec![kind];
+
+					let mut idx = idx;
+					let mut forward_parent = forward_parent;
+
+					// Walk through the forward parent of the forward parent, and the forward parent
+					// of that, and of that, etc. until we reach a StartNode event without a forward
+					// parent.
+					while let Some(fp) = forward_parent {
+						idx += fp.get();
+
+						forward_parent = if let Event::Start {
+							kind,
+							forward_parent,
+						} = mem::replace(&mut self.events[idx], Event::Noop)
+						{
+							kinds.push(kind);
+							forward_parent
+						} else {
+							unreachable!()
+						};
+					}
+
+					for kind in kinds.into_iter().rev() {
+						self.builder.start_node(JsonnetLanguage::kind_to_raw(kind));
+						depth += 1;
+						if depth == 1 {
+							self.skip_whitespace();
+						}
+						error_starts_at.push(self.text_offset());
+					}
+
+					eat_start_whitespace = false;
+				}
+				Event::Token { kind } => {
+					if eat_start_whitespace {
+						self.skip_whitespace();
+					}
+					self.token(kind);
+					eat_start_whitespace = true;
+				}
+				Event::VirtualToken { kind } => {
+					if eat_start_whitespace {
+						self.skip_whitespace();
+					}
+					self.virtual_token(kind);
+					eat_start_whitespace = false;
+				}
+				Event::Finish { wrapper, error } => {
+					if depth == 1 {
+						self.skip_whitespace();
+					}
+					let range = (
+						error_starts_at.pop().expect("starts == finishes"),
+						self.text_offset(),
+					);
+					if let Some(error) = error {
+						self.errors.push(LocatedSyntaxError {
+							error: *error,
+							range: TextRange::new(range.0, range.1),
+						})
+					}
+					self.builder.finish_node();
+					depth -= 1;
+					let mut idx = idx;
+					let mut wrapper = wrapper;
+					while let Some(w) = wrapper {
+						idx += w.get();
+						wrapper = if let Event::Finish { wrapper, error } =
+							mem::replace(&mut self.events[idx], Event::Noop)
+						{
+							let range = (
+								error_starts_at.pop().expect("starts == finishes"),
+								self.text_offset(),
+							);
+							if let Some(error) = error {
+								self.errors.push(LocatedSyntaxError {
+									error: *error,
+									range: TextRange::new(range.0, range.1),
+								})
+							}
+
+							if depth == 1 {
+								self.skip_whitespace();
+							}
+							self.builder.finish_node();
+							depth -= 1;
+							wrapper
+						} else {
+							unreachable!()
+						}
+					}
+					eat_start_whitespace = true;
+				}
+				Event::Pending => panic!("pending event should not appear in finished events"),
+				Event::Noop => {}
+			}
+		}
+
+		Parse {
+			green_node: self.builder.finish(),
+			errors: self.errors,
+		}
+	}
+	fn virtual_token(&mut self, kind: SyntaxKind) {
+		self.builder.token(JsonnetLanguage::kind_to_raw(kind), "")
+	}
+	fn token(&mut self, kind: SyntaxKind) {
+		let lexeme = self.lexemes[self.offset];
+		self.builder
+			.token(JsonnetLanguage::kind_to_raw(kind), lexeme.text);
+		self.offset += 1;
+	}
+	fn skip_whitespace(&mut self) {
+		while let Some(lexeme) = self.lexemes.get(self.offset) {
+			if !Trivia::can_cast(lexeme.kind) {
+				break;
+			}
+
+			self.token(lexeme.kind);
+		}
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/generated/mod.rs
@@ -0,0 +1,2 @@
+pub mod nodes;
+pub mod syntax_kinds;

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/generated/nodes.rs
@@ -0,0 +1,3092 @@
+//! This is a generated file, please do not edit manually. Changes can be
+//! made in codegeneration that lives in `xtask` top-level dir.
+
+#![allow(non_snake_case, clippy::match_like_matches_macro)]
+use crate::{
+	ast::{support, AstChildren, AstNode, AstToken},
+	SyntaxKind::{self, *},
+	SyntaxNode, SyntaxToken, T,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SourceFile {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SourceFile {
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Expr {
+	pub(crate) syntax: SyntaxNode,
+}
+impl Expr {
+	pub fn stmts(&self) -> AstChildren<Stmt> {
+		support::children(&self.syntax)
+	}
+	pub fn expr_base(&self) -> Option<ExprBase> {
+		support::child(&self.syntax)
+	}
+	pub fn suffixs(&self) -> AstChildren<Suffix> {
+		support::children(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SuffixIndex {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SuffixIndex {
+	pub fn question_mark_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![?])
+	}
+	pub fn dot_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![.])
+	}
+	pub fn index(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Name {
+	pub(crate) syntax: SyntaxNode,
+}
+impl Name {
+	pub fn ident_lit(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, IDENT)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SuffixIndexExpr {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SuffixIndexExpr {
+	pub fn question_mark_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![?])
+	}
+	pub fn dot_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![.])
+	}
+	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['['])
+	}
+	pub fn index(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![']'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SuffixSlice {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SuffixSlice {
+	pub fn slice_desc(&self) -> Option<SliceDesc> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SliceDesc {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SliceDesc {
+	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['['])
+	}
+	pub fn from(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn colon_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![:])
+	}
+	pub fn end(&self) -> Option<SliceDescEnd> {
+		support::child(&self.syntax)
+	}
+	pub fn step(&self) -> Option<SliceDescStep> {
+		support::child(&self.syntax)
+	}
+	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![']'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SuffixApply {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SuffixApply {
+	pub fn args_desc(&self) -> Option<ArgsDesc> {
+		support::child(&self.syntax)
+	}
+	pub fn tailstrict_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![tailstrict])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ArgsDesc {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ArgsDesc {
+	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['('])
+	}
+	pub fn args(&self) -> AstChildren<Arg> {
+		support::children(&self.syntax)
+	}
+	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![')'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct StmtLocal {
+	pub(crate) syntax: SyntaxNode,
+}
+impl StmtLocal {
+	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![local])
+	}
+	pub fn binds(&self) -> AstChildren<Bind> {
+		support::children(&self.syntax)
+	}
+	pub fn semi_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![;])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct StmtAssert {
+	pub(crate) syntax: SyntaxNode,
+}
+impl StmtAssert {
+	pub fn assertion(&self) -> Option<Assertion> {
+		support::child(&self.syntax)
+	}
+	pub fn semi_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![;])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Assertion {
+	pub(crate) syntax: SyntaxNode,
+}
+impl Assertion {
+	pub fn assert_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![assert])
+	}
+	pub fn condition(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn colon_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![:])
+	}
+	pub fn message(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprBinary {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprBinary {
+	pub fn lhs(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn binary_operator(&self) -> Option<BinaryOperator> {
+		support::token_child(&self.syntax)
+	}
+	pub fn rhs(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprUnary {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprUnary {
+	pub fn unary_operator(&self) -> Option<UnaryOperator> {
+		support::token_child(&self.syntax)
+	}
+	pub fn rhs(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprObjExtend {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprObjExtend {
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprParened {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprParened {
+	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['('])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![')'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprLiteral {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprLiteral {
+	pub fn literal(&self) -> Option<Literal> {
+		support::token_child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprString {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprString {
+	pub fn text(&self) -> Option<Text> {
+		support::token_child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprNumber {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprNumber {
+	pub fn number(&self) -> Option<Number> {
+		support::token_child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprArray {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprArray {
+	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['['])
+	}
+	pub fn exprs(&self) -> AstChildren<Expr> {
+		support::children(&self.syntax)
+	}
+	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![']'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprObject {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprObject {
+	pub fn obj_body(&self) -> Option<ObjBody> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprArrayComp {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprArrayComp {
+	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['['])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn comma_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![,])
+	}
+	pub fn comp_specs(&self) -> AstChildren<CompSpec> {
+		support::children(&self.syntax)
+	}
+	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![']'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprImport {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprImport {
+	pub fn import_kind(&self) -> Option<ImportKind> {
+		support::token_child(&self.syntax)
+	}
+	pub fn text(&self) -> Option<Text> {
+		support::token_child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprVar {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprVar {
+	pub fn name(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprIfThenElse {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprIfThenElse {
+	pub fn if_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![if])
+	}
+	pub fn cond(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn then_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![then])
+	}
+	pub fn then(&self) -> Option<TrueExpr> {
+		support::child(&self.syntax)
+	}
+	pub fn else_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![else])
+	}
+	pub fn else_(&self) -> Option<FalseExpr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TrueExpr {
+	pub(crate) syntax: SyntaxNode,
+}
+impl TrueExpr {
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FalseExpr {
+	pub(crate) syntax: SyntaxNode,
+}
+impl FalseExpr {
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprFunction {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprFunction {
+	pub fn function_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![function])
+	}
+	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['('])
+	}
+	pub fn params_desc(&self) -> Option<ParamsDesc> {
+		support::child(&self.syntax)
+	}
+	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![')'])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParamsDesc {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ParamsDesc {
+	pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['('])
+	}
+	pub fn params(&self) -> AstChildren<Param> {
+		support::children(&self.syntax)
+	}
+	pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![')'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExprError {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ExprError {
+	pub fn error_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![error])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SliceDescEnd {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SliceDescEnd {
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SliceDescStep {
+	pub(crate) syntax: SyntaxNode,
+}
+impl SliceDescStep {
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Arg {
+	pub(crate) syntax: SyntaxNode,
+}
+impl Arg {
+	pub fn name(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+	pub fn assign_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![=])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ObjBodyComp {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ObjBodyComp {
+	pub fn l_brace_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['{'])
+	}
+	pub fn member_comps(&self) -> AstChildren<MemberComp> {
+		support::children(&self.syntax)
+	}
+	pub fn comp_specs(&self) -> AstChildren<CompSpec> {
+		support::children(&self.syntax)
+	}
+	pub fn r_brace_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['}'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ObjBodyMemberList {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ObjBodyMemberList {
+	pub fn l_brace_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['{'])
+	}
+	pub fn members(&self) -> AstChildren<Member> {
+		support::children(&self.syntax)
+	}
+	pub fn r_brace_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['}'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MemberBindStmt {
+	pub(crate) syntax: SyntaxNode,
+}
+impl MemberBindStmt {
+	pub fn obj_local(&self) -> Option<ObjLocal> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ObjLocal {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ObjLocal {
+	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![local])
+	}
+	pub fn bind(&self) -> Option<Bind> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MemberAssertStmt {
+	pub(crate) syntax: SyntaxNode,
+}
+impl MemberAssertStmt {
+	pub fn assertion(&self) -> Option<Assertion> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MemberFieldNormal {
+	pub(crate) syntax: SyntaxNode,
+}
+impl MemberFieldNormal {
+	pub fn field_name(&self) -> Option<FieldName> {
+		support::child(&self.syntax)
+	}
+	pub fn plus_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![+])
+	}
+	pub fn visibility(&self) -> Option<Visibility> {
+		support::token_child(&self.syntax)
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MemberFieldMethod {
+	pub(crate) syntax: SyntaxNode,
+}
+impl MemberFieldMethod {
+	pub fn field_name(&self) -> Option<FieldName> {
+		support::child(&self.syntax)
+	}
+	pub fn params_desc(&self) -> Option<ParamsDesc> {
+		support::child(&self.syntax)
+	}
+	pub fn visibility(&self) -> Option<Visibility> {
+		support::token_child(&self.syntax)
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FieldNameFixed {
+	pub(crate) syntax: SyntaxNode,
+}
+impl FieldNameFixed {
+	pub fn id(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+	pub fn text(&self) -> Option<Text> {
+		support::token_child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FieldNameDynamic {
+	pub(crate) syntax: SyntaxNode,
+}
+impl FieldNameDynamic {
+	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['['])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![']'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ForSpec {
+	pub(crate) syntax: SyntaxNode,
+}
+impl ForSpec {
+	pub fn for_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![for])
+	}
+	pub fn bind(&self) -> Option<Destruct> {
+		support::child(&self.syntax)
+	}
+	pub fn in_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![in])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IfSpec {
+	pub(crate) syntax: SyntaxNode,
+}
+impl IfSpec {
+	pub fn if_kw_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![if])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct BindDestruct {
+	pub(crate) syntax: SyntaxNode,
+}
+impl BindDestruct {
+	pub fn into(&self) -> Option<Destruct> {
+		support::child(&self.syntax)
+	}
+	pub fn assign_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![=])
+	}
+	pub fn value(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct BindFunction {
+	pub(crate) syntax: SyntaxNode,
+}
+impl BindFunction {
+	pub fn name(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+	pub fn params(&self) -> Option<ParamsDesc> {
+		support::child(&self.syntax)
+	}
+	pub fn assign_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![=])
+	}
+	pub fn value(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Param {
+	pub(crate) syntax: SyntaxNode,
+}
+impl Param {
+	pub fn destruct(&self) -> Option<Destruct> {
+		support::child(&self.syntax)
+	}
+	pub fn assign_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![=])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructFull {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructFull {
+	pub fn name(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructSkip {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructSkip {
+	pub fn question_mark_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![?])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructArray {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructArray {
+	pub fn l_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['['])
+	}
+	pub fn destruct_array_parts(&self) -> AstChildren<DestructArrayPart> {
+		support::children(&self.syntax)
+	}
+	pub fn r_brack_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![']'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructObject {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructObject {
+	pub fn l_brace_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['{'])
+	}
+	pub fn destruct_object_fields(&self) -> AstChildren<DestructObjectField> {
+		support::children(&self.syntax)
+	}
+	pub fn destruct_rest(&self) -> Option<DestructRest> {
+		support::child(&self.syntax)
+	}
+	pub fn comma_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![,])
+	}
+	pub fn r_brace_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T!['}'])
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructObjectField {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructObjectField {
+	pub fn field(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+	pub fn colon_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![:])
+	}
+	pub fn destruct(&self) -> Option<Destruct> {
+		support::child(&self.syntax)
+	}
+	pub fn assign_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![=])
+	}
+	pub fn expr(&self) -> Option<Expr> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructRest {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructRest {
+	pub fn dotdotdot_token(&self) -> Option<SyntaxToken> {
+		support::token(&self.syntax, T![...])
+	}
+	pub fn into(&self) -> Option<Name> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DestructArrayElement {
+	pub(crate) syntax: SyntaxNode,
+}
+impl DestructArrayElement {
+	pub fn destruct(&self) -> Option<Destruct> {
+		support::child(&self.syntax)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Suffix {
+	SuffixIndex(SuffixIndex),
+	SuffixIndexExpr(SuffixIndexExpr),
+	SuffixSlice(SuffixSlice),
+	SuffixApply(SuffixApply),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Bind {
+	BindDestruct(BindDestruct),
+	BindFunction(BindFunction),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Stmt {
+	StmtLocal(StmtLocal),
+	StmtAssert(StmtAssert),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ObjBody {
+	ObjBodyComp(ObjBodyComp),
+	ObjBodyMemberList(ObjBodyMemberList),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum CompSpec {
+	ForSpec(ForSpec),
+	IfSpec(IfSpec),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ExprBase {
+	ExprBinary(ExprBinary),
+	ExprUnary(ExprUnary),
+	ExprObjExtend(ExprObjExtend),
+	ExprParened(ExprParened),
+	ExprString(ExprString),
+	ExprNumber(ExprNumber),
+	ExprLiteral(ExprLiteral),
+	ExprArray(ExprArray),
+	ExprObject(ExprObject),
+	ExprArrayComp(ExprArrayComp),
+	ExprImport(ExprImport),
+	ExprVar(ExprVar),
+	ExprIfThenElse(ExprIfThenElse),
+	ExprFunction(ExprFunction),
+	ExprError(ExprError),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum MemberComp {
+	MemberBindStmt(MemberBindStmt),
+	MemberFieldNormal(MemberFieldNormal),
+	MemberFieldMethod(MemberFieldMethod),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Member {
+	MemberBindStmt(MemberBindStmt),
+	MemberAssertStmt(MemberAssertStmt),
+	MemberFieldNormal(MemberFieldNormal),
+	MemberFieldMethod(MemberFieldMethod),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum FieldName {
+	FieldNameFixed(FieldNameFixed),
+	FieldNameDynamic(FieldNameDynamic),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Destruct {
+	DestructFull(DestructFull),
+	DestructSkip(DestructSkip),
+	DestructArray(DestructArray),
+	DestructObject(DestructObject),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum DestructArrayPart {
+	DestructArrayElement(DestructArrayElement),
+	DestructRest(DestructRest),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct BinaryOperator {
+	syntax: SyntaxToken,
+	kind: BinaryOperatorKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum BinaryOperatorKind {
+	Or,
+	NullCoaelse,
+	And,
+	BitOr,
+	BitXor,
+	BitAnd,
+	Eq,
+	Ne,
+	Lt,
+	Gt,
+	Le,
+	Ge,
+	InKw,
+	Lhs,
+	Rhs,
+	Plus,
+	Minus,
+	Mul,
+	Div,
+	Modulo,
+	MetaObjectApply,
+	ErrorNoOperator,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct UnaryOperator {
+	syntax: SyntaxToken,
+	kind: UnaryOperatorKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum UnaryOperatorKind {
+	Minus,
+	Not,
+	BitNot,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Literal {
+	syntax: SyntaxToken,
+	kind: LiteralKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LiteralKind {
+	NullKw,
+	TrueKw,
+	FalseKw,
+	SelfKw,
+	Dollar,
+	SuperKw,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Text {
+	syntax: SyntaxToken,
+	kind: TextKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TextKind {
+	StringDouble,
+	ErrorStringDoubleUnterminated,
+	StringSingle,
+	ErrorStringSingleUnterminated,
+	StringDoubleVerbatim,
+	ErrorStringDoubleVerbatimUnterminated,
+	StringSingleVerbatim,
+	ErrorStringSingleVerbatimUnterminated,
+	ErrorStringVerbatimMissingQuotes,
+	StringBlock,
+	ErrorStringBlockUnexpectedEnd,
+	ErrorStringBlockMissingNewLine,
+	ErrorStringBlockMissingTermination,
+	ErrorStringBlockMissingIndent,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Number {
+	syntax: SyntaxToken,
+	kind: NumberKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum NumberKind {
+	Float,
+	ErrorFloatJunkAfterPoint,
+	ErrorFloatJunkAfterExponent,
+	ErrorFloatJunkAfterExponentSign,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ImportKind {
+	syntax: SyntaxToken,
+	kind: ImportKindKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ImportKindKind {
+	ImportstrKw,
+	ImportbinKw,
+	ImportKw,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Visibility {
+	syntax: SyntaxToken,
+	kind: VisibilityKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum VisibilityKind {
+	Coloncoloncolon,
+	Coloncolon,
+	Colon,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Trivia {
+	syntax: SyntaxToken,
+	kind: TriviaKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TriviaKind {
+	Whitespace,
+	MultiLineComment,
+	ErrorCommentTooShort,
+	ErrorCommentUnterminated,
+	SingleLineHashComment,
+	SingleLineSlashComment,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CustomError {
+	syntax: SyntaxToken,
+	kind: CustomErrorKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum CustomErrorKind {
+	ErrorMissingToken,
+	ErrorUnexpectedToken,
+	ErrorCustom,
+}
+impl AstNode for SourceFile {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SOURCE_FILE
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for Expr {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SuffixIndex {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SUFFIX_INDEX
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for Name {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == NAME
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SuffixIndexExpr {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SUFFIX_INDEX_EXPR
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SuffixSlice {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SUFFIX_SLICE
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SliceDesc {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SLICE_DESC
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SuffixApply {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SUFFIX_APPLY
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ArgsDesc {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == ARGS_DESC
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for StmtLocal {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == STMT_LOCAL
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for StmtAssert {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == STMT_ASSERT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for Assertion {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == ASSERTION
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprBinary {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_BINARY
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprUnary {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_UNARY
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprObjExtend {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_OBJ_EXTEND
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprParened {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_PARENED
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprLiteral {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_LITERAL
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprString {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_STRING
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprNumber {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_NUMBER
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprArray {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_ARRAY
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprObject {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_OBJECT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprArrayComp {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_ARRAY_COMP
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprImport {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_IMPORT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprVar {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_VAR
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprIfThenElse {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_IF_THEN_ELSE
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for TrueExpr {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == TRUE_EXPR
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for FalseExpr {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == FALSE_EXPR
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprFunction {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_FUNCTION
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ParamsDesc {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == PARAMS_DESC
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ExprError {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == EXPR_ERROR
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SliceDescEnd {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SLICE_DESC_END
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for SliceDescStep {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == SLICE_DESC_STEP
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for Arg {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == ARG
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ObjBodyComp {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == OBJ_BODY_COMP
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ObjBodyMemberList {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == OBJ_BODY_MEMBER_LIST
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for MemberBindStmt {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == MEMBER_BIND_STMT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ObjLocal {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == OBJ_LOCAL
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for MemberAssertStmt {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == MEMBER_ASSERT_STMT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for MemberFieldNormal {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == MEMBER_FIELD_NORMAL
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for MemberFieldMethod {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == MEMBER_FIELD_METHOD
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for FieldNameFixed {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == FIELD_NAME_FIXED
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for FieldNameDynamic {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == FIELD_NAME_DYNAMIC
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for ForSpec {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == FOR_SPEC
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for IfSpec {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == IF_SPEC
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for BindDestruct {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == BIND_DESTRUCT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for BindFunction {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == BIND_FUNCTION
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for Param {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == PARAM
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructFull {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_FULL
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructSkip {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_SKIP
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructArray {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_ARRAY
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructObject {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_OBJECT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructObjectField {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_OBJECT_FIELD
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructRest {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_REST
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl AstNode for DestructArrayElement {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		kind == DESTRUCT_ARRAY_ELEMENT
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		&self.syntax
+	}
+}
+impl From<SuffixIndex> for Suffix {
+	fn from(node: SuffixIndex) -> Suffix {
+		Suffix::SuffixIndex(node)
+	}
+}
+impl From<SuffixIndexExpr> for Suffix {
+	fn from(node: SuffixIndexExpr) -> Suffix {
+		Suffix::SuffixIndexExpr(node)
+	}
+}
+impl From<SuffixSlice> for Suffix {
+	fn from(node: SuffixSlice) -> Suffix {
+		Suffix::SuffixSlice(node)
+	}
+}
+impl From<SuffixApply> for Suffix {
+	fn from(node: SuffixApply) -> Suffix {
+		Suffix::SuffixApply(node)
+	}
+}
+impl AstNode for Suffix {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			SUFFIX_INDEX | SUFFIX_INDEX_EXPR | SUFFIX_SLICE | SUFFIX_APPLY => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			SUFFIX_INDEX => Suffix::SuffixIndex(SuffixIndex { syntax }),
+			SUFFIX_INDEX_EXPR => Suffix::SuffixIndexExpr(SuffixIndexExpr { syntax }),
+			SUFFIX_SLICE => Suffix::SuffixSlice(SuffixSlice { syntax }),
+			SUFFIX_APPLY => Suffix::SuffixApply(SuffixApply { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			Suffix::SuffixIndex(it) => &it.syntax,
+			Suffix::SuffixIndexExpr(it) => &it.syntax,
+			Suffix::SuffixSlice(it) => &it.syntax,
+			Suffix::SuffixApply(it) => &it.syntax,
+		}
+	}
+}
+impl From<BindDestruct> for Bind {
+	fn from(node: BindDestruct) -> Bind {
+		Bind::BindDestruct(node)
+	}
+}
+impl From<BindFunction> for Bind {
+	fn from(node: BindFunction) -> Bind {
+		Bind::BindFunction(node)
+	}
+}
+impl AstNode for Bind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			BIND_DESTRUCT | BIND_FUNCTION => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			BIND_DESTRUCT => Bind::BindDestruct(BindDestruct { syntax }),
+			BIND_FUNCTION => Bind::BindFunction(BindFunction { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			Bind::BindDestruct(it) => &it.syntax,
+			Bind::BindFunction(it) => &it.syntax,
+		}
+	}
+}
+impl From<StmtLocal> for Stmt {
+	fn from(node: StmtLocal) -> Stmt {
+		Stmt::StmtLocal(node)
+	}
+}
+impl From<StmtAssert> for Stmt {
+	fn from(node: StmtAssert) -> Stmt {
+		Stmt::StmtAssert(node)
+	}
+}
+impl AstNode for Stmt {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			STMT_LOCAL | STMT_ASSERT => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			STMT_LOCAL => Stmt::StmtLocal(StmtLocal { syntax }),
+			STMT_ASSERT => Stmt::StmtAssert(StmtAssert { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			Stmt::StmtLocal(it) => &it.syntax,
+			Stmt::StmtAssert(it) => &it.syntax,
+		}
+	}
+}
+impl From<ObjBodyComp> for ObjBody {
+	fn from(node: ObjBodyComp) -> ObjBody {
+		ObjBody::ObjBodyComp(node)
+	}
+}
+impl From<ObjBodyMemberList> for ObjBody {
+	fn from(node: ObjBodyMemberList) -> ObjBody {
+		ObjBody::ObjBodyMemberList(node)
+	}
+}
+impl AstNode for ObjBody {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			OBJ_BODY_COMP | OBJ_BODY_MEMBER_LIST => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			OBJ_BODY_COMP => ObjBody::ObjBodyComp(ObjBodyComp { syntax }),
+			OBJ_BODY_MEMBER_LIST => ObjBody::ObjBodyMemberList(ObjBodyMemberList { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			ObjBody::ObjBodyComp(it) => &it.syntax,
+			ObjBody::ObjBodyMemberList(it) => &it.syntax,
+		}
+	}
+}
+impl From<ForSpec> for CompSpec {
+	fn from(node: ForSpec) -> CompSpec {
+		CompSpec::ForSpec(node)
+	}
+}
+impl From<IfSpec> for CompSpec {
+	fn from(node: IfSpec) -> CompSpec {
+		CompSpec::IfSpec(node)
+	}
+}
+impl AstNode for CompSpec {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			FOR_SPEC | IF_SPEC => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			FOR_SPEC => CompSpec::ForSpec(ForSpec { syntax }),
+			IF_SPEC => CompSpec::IfSpec(IfSpec { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			CompSpec::ForSpec(it) => &it.syntax,
+			CompSpec::IfSpec(it) => &it.syntax,
+		}
+	}
+}
+impl From<ExprBinary> for ExprBase {
+	fn from(node: ExprBinary) -> ExprBase {
+		ExprBase::ExprBinary(node)
+	}
+}
+impl From<ExprUnary> for ExprBase {
+	fn from(node: ExprUnary) -> ExprBase {
+		ExprBase::ExprUnary(node)
+	}
+}
+impl From<ExprObjExtend> for ExprBase {
+	fn from(node: ExprObjExtend) -> ExprBase {
+		ExprBase::ExprObjExtend(node)
+	}
+}
+impl From<ExprParened> for ExprBase {
+	fn from(node: ExprParened) -> ExprBase {
+		ExprBase::ExprParened(node)
+	}
+}
+impl From<ExprString> for ExprBase {
+	fn from(node: ExprString) -> ExprBase {
+		ExprBase::ExprString(node)
+	}
+}
+impl From<ExprNumber> for ExprBase {
+	fn from(node: ExprNumber) -> ExprBase {
+		ExprBase::ExprNumber(node)
+	}
+}
+impl From<ExprLiteral> for ExprBase {
+	fn from(node: ExprLiteral) -> ExprBase {
+		ExprBase::ExprLiteral(node)
+	}
+}
+impl From<ExprArray> for ExprBase {
+	fn from(node: ExprArray) -> ExprBase {
+		ExprBase::ExprArray(node)
+	}
+}
+impl From<ExprObject> for ExprBase {
+	fn from(node: ExprObject) -> ExprBase {
+		ExprBase::ExprObject(node)
+	}
+}
+impl From<ExprArrayComp> for ExprBase {
+	fn from(node: ExprArrayComp) -> ExprBase {
+		ExprBase::ExprArrayComp(node)
+	}
+}
+impl From<ExprImport> for ExprBase {
+	fn from(node: ExprImport) -> ExprBase {
+		ExprBase::ExprImport(node)
+	}
+}
+impl From<ExprVar> for ExprBase {
+	fn from(node: ExprVar) -> ExprBase {
+		ExprBase::ExprVar(node)
+	}
+}
+impl From<ExprIfThenElse> for ExprBase {
+	fn from(node: ExprIfThenElse) -> ExprBase {
+		ExprBase::ExprIfThenElse(node)
+	}
+}
+impl From<ExprFunction> for ExprBase {
+	fn from(node: ExprFunction) -> ExprBase {
+		ExprBase::ExprFunction(node)
+	}
+}
+impl From<ExprError> for ExprBase {
+	fn from(node: ExprError) -> ExprBase {
+		ExprBase::ExprError(node)
+	}
+}
+impl AstNode for ExprBase {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			EXPR_BINARY | EXPR_UNARY | EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING
+			| EXPR_NUMBER | EXPR_LITERAL | EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP
+			| EXPR_IMPORT | EXPR_VAR | EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ERROR => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),
+			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),
+			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),
+			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),
+			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),
+			EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),
+			EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),
+			EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),
+			EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),
+			EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),
+			EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),
+			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),
+			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),
+			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),
+			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			ExprBase::ExprBinary(it) => &it.syntax,
+			ExprBase::ExprUnary(it) => &it.syntax,
+			ExprBase::ExprObjExtend(it) => &it.syntax,
+			ExprBase::ExprParened(it) => &it.syntax,
+			ExprBase::ExprString(it) => &it.syntax,
+			ExprBase::ExprNumber(it) => &it.syntax,
+			ExprBase::ExprLiteral(it) => &it.syntax,
+			ExprBase::ExprArray(it) => &it.syntax,
+			ExprBase::ExprObject(it) => &it.syntax,
+			ExprBase::ExprArrayComp(it) => &it.syntax,
+			ExprBase::ExprImport(it) => &it.syntax,
+			ExprBase::ExprVar(it) => &it.syntax,
+			ExprBase::ExprIfThenElse(it) => &it.syntax,
+			ExprBase::ExprFunction(it) => &it.syntax,
+			ExprBase::ExprError(it) => &it.syntax,
+		}
+	}
+}
+impl From<MemberBindStmt> for MemberComp {
+	fn from(node: MemberBindStmt) -> MemberComp {
+		MemberComp::MemberBindStmt(node)
+	}
+}
+impl From<MemberFieldNormal> for MemberComp {
+	fn from(node: MemberFieldNormal) -> MemberComp {
+		MemberComp::MemberFieldNormal(node)
+	}
+}
+impl From<MemberFieldMethod> for MemberComp {
+	fn from(node: MemberFieldMethod) -> MemberComp {
+		MemberComp::MemberFieldMethod(node)
+	}
+}
+impl AstNode for MemberComp {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			MEMBER_BIND_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			MEMBER_BIND_STMT => MemberComp::MemberBindStmt(MemberBindStmt { syntax }),
+			MEMBER_FIELD_NORMAL => MemberComp::MemberFieldNormal(MemberFieldNormal { syntax }),
+			MEMBER_FIELD_METHOD => MemberComp::MemberFieldMethod(MemberFieldMethod { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			MemberComp::MemberBindStmt(it) => &it.syntax,
+			MemberComp::MemberFieldNormal(it) => &it.syntax,
+			MemberComp::MemberFieldMethod(it) => &it.syntax,
+		}
+	}
+}
+impl From<MemberBindStmt> for Member {
+	fn from(node: MemberBindStmt) -> Member {
+		Member::MemberBindStmt(node)
+	}
+}
+impl From<MemberAssertStmt> for Member {
+	fn from(node: MemberAssertStmt) -> Member {
+		Member::MemberAssertStmt(node)
+	}
+}
+impl From<MemberFieldNormal> for Member {
+	fn from(node: MemberFieldNormal) -> Member {
+		Member::MemberFieldNormal(node)
+	}
+}
+impl From<MemberFieldMethod> for Member {
+	fn from(node: MemberFieldMethod) -> Member {
+		Member::MemberFieldMethod(node)
+	}
+}
+impl AstNode for Member {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {
+				true
+			}
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),
+			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),
+			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),
+			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			Member::MemberBindStmt(it) => &it.syntax,
+			Member::MemberAssertStmt(it) => &it.syntax,
+			Member::MemberFieldNormal(it) => &it.syntax,
+			Member::MemberFieldMethod(it) => &it.syntax,
+		}
+	}
+}
+impl From<FieldNameFixed> for FieldName {
+	fn from(node: FieldNameFixed) -> FieldName {
+		FieldName::FieldNameFixed(node)
+	}
+}
+impl From<FieldNameDynamic> for FieldName {
+	fn from(node: FieldNameDynamic) -> FieldName {
+		FieldName::FieldNameDynamic(node)
+	}
+}
+impl AstNode for FieldName {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			FIELD_NAME_FIXED | FIELD_NAME_DYNAMIC => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			FIELD_NAME_FIXED => FieldName::FieldNameFixed(FieldNameFixed { syntax }),
+			FIELD_NAME_DYNAMIC => FieldName::FieldNameDynamic(FieldNameDynamic { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			FieldName::FieldNameFixed(it) => &it.syntax,
+			FieldName::FieldNameDynamic(it) => &it.syntax,
+		}
+	}
+}
+impl From<DestructFull> for Destruct {
+	fn from(node: DestructFull) -> Destruct {
+		Destruct::DestructFull(node)
+	}
+}
+impl From<DestructSkip> for Destruct {
+	fn from(node: DestructSkip) -> Destruct {
+		Destruct::DestructSkip(node)
+	}
+}
+impl From<DestructArray> for Destruct {
+	fn from(node: DestructArray) -> Destruct {
+		Destruct::DestructArray(node)
+	}
+}
+impl From<DestructObject> for Destruct {
+	fn from(node: DestructObject) -> Destruct {
+		Destruct::DestructObject(node)
+	}
+}
+impl AstNode for Destruct {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			DESTRUCT_FULL | DESTRUCT_SKIP | DESTRUCT_ARRAY | DESTRUCT_OBJECT => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			DESTRUCT_FULL => Destruct::DestructFull(DestructFull { syntax }),
+			DESTRUCT_SKIP => Destruct::DestructSkip(DestructSkip { syntax }),
+			DESTRUCT_ARRAY => Destruct::DestructArray(DestructArray { syntax }),
+			DESTRUCT_OBJECT => Destruct::DestructObject(DestructObject { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			Destruct::DestructFull(it) => &it.syntax,
+			Destruct::DestructSkip(it) => &it.syntax,
+			Destruct::DestructArray(it) => &it.syntax,
+			Destruct::DestructObject(it) => &it.syntax,
+		}
+	}
+}
+impl From<DestructArrayElement> for DestructArrayPart {
+	fn from(node: DestructArrayElement) -> DestructArrayPart {
+		DestructArrayPart::DestructArrayElement(node)
+	}
+}
+impl From<DestructRest> for DestructArrayPart {
+	fn from(node: DestructRest) -> DestructArrayPart {
+		DestructArrayPart::DestructRest(node)
+	}
+}
+impl AstNode for DestructArrayPart {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			DESTRUCT_ARRAY_ELEMENT | DESTRUCT_REST => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			DESTRUCT_ARRAY_ELEMENT => {
+				DestructArrayPart::DestructArrayElement(DestructArrayElement { syntax })
+			}
+			DESTRUCT_REST => DestructArrayPart::DestructRest(DestructRest { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			DestructArrayPart::DestructArrayElement(it) => &it.syntax,
+			DestructArrayPart::DestructRest(it) => &it.syntax,
+		}
+	}
+}
+impl AstToken for BinaryOperator {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		BinaryOperatorKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = BinaryOperatorKind::cast(syntax.kind())?;
+		Some(BinaryOperator { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl BinaryOperatorKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE
+			| IN_KW | LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | META_OBJECT_APPLY
+			| ERROR_NO_OPERATOR => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			OR => Self::Or,
+			NULL_COAELSE => Self::NullCoaelse,
+			AND => Self::And,
+			BIT_OR => Self::BitOr,
+			BIT_XOR => Self::BitXor,
+			BIT_AND => Self::BitAnd,
+			EQ => Self::Eq,
+			NE => Self::Ne,
+			LT => Self::Lt,
+			GT => Self::Gt,
+			LE => Self::Le,
+			GE => Self::Ge,
+			IN_KW => Self::InKw,
+			LHS => Self::Lhs,
+			RHS => Self::Rhs,
+			PLUS => Self::Plus,
+			MINUS => Self::Minus,
+			MUL => Self::Mul,
+			DIV => Self::Div,
+			MODULO => Self::Modulo,
+			META_OBJECT_APPLY => Self::MetaObjectApply,
+			ERROR_NO_OPERATOR => Self::ErrorNoOperator,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl BinaryOperator {
+	pub fn kind(&self) -> BinaryOperatorKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for BinaryOperator {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for UnaryOperator {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		UnaryOperatorKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = UnaryOperatorKind::cast(syntax.kind())?;
+		Some(UnaryOperator { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl UnaryOperatorKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			MINUS | NOT | BIT_NOT => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			MINUS => Self::Minus,
+			NOT => Self::Not,
+			BIT_NOT => Self::BitNot,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl UnaryOperator {
+	pub fn kind(&self) -> UnaryOperatorKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for UnaryOperator {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for Literal {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		LiteralKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = LiteralKind::cast(syntax.kind())?;
+		Some(Literal { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl LiteralKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | DOLLAR | SUPER_KW => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			NULL_KW => Self::NullKw,
+			TRUE_KW => Self::TrueKw,
+			FALSE_KW => Self::FalseKw,
+			SELF_KW => Self::SelfKw,
+			DOLLAR => Self::Dollar,
+			SUPER_KW => Self::SuperKw,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl Literal {
+	pub fn kind(&self) -> LiteralKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for Literal {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for Text {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		TextKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = TextKind::cast(syntax.kind())?;
+		Some(Text { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl TextKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			STRING_DOUBLE
+			| ERROR_STRING_DOUBLE_UNTERMINATED
+			| STRING_SINGLE
+			| ERROR_STRING_SINGLE_UNTERMINATED
+			| STRING_DOUBLE_VERBATIM
+			| ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED
+			| STRING_SINGLE_VERBATIM
+			| ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED
+			| ERROR_STRING_VERBATIM_MISSING_QUOTES
+			| STRING_BLOCK
+			| ERROR_STRING_BLOCK_UNEXPECTED_END
+			| ERROR_STRING_BLOCK_MISSING_NEW_LINE
+			| ERROR_STRING_BLOCK_MISSING_TERMINATION
+			| ERROR_STRING_BLOCK_MISSING_INDENT => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			STRING_DOUBLE => Self::StringDouble,
+			ERROR_STRING_DOUBLE_UNTERMINATED => Self::ErrorStringDoubleUnterminated,
+			STRING_SINGLE => Self::StringSingle,
+			ERROR_STRING_SINGLE_UNTERMINATED => Self::ErrorStringSingleUnterminated,
+			STRING_DOUBLE_VERBATIM => Self::StringDoubleVerbatim,
+			ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED => {
+				Self::ErrorStringDoubleVerbatimUnterminated
+			}
+			STRING_SINGLE_VERBATIM => Self::StringSingleVerbatim,
+			ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED => {
+				Self::ErrorStringSingleVerbatimUnterminated
+			}
+			ERROR_STRING_VERBATIM_MISSING_QUOTES => Self::ErrorStringVerbatimMissingQuotes,
+			STRING_BLOCK => Self::StringBlock,
+			ERROR_STRING_BLOCK_UNEXPECTED_END => Self::ErrorStringBlockUnexpectedEnd,
+			ERROR_STRING_BLOCK_MISSING_NEW_LINE => Self::ErrorStringBlockMissingNewLine,
+			ERROR_STRING_BLOCK_MISSING_TERMINATION => Self::ErrorStringBlockMissingTermination,
+			ERROR_STRING_BLOCK_MISSING_INDENT => Self::ErrorStringBlockMissingIndent,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl Text {
+	pub fn kind(&self) -> TextKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for Text {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for Number {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		NumberKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = NumberKind::cast(syntax.kind())?;
+		Some(Number { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl NumberKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			FLOAT
+			| ERROR_FLOAT_JUNK_AFTER_POINT
+			| ERROR_FLOAT_JUNK_AFTER_EXPONENT
+			| ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			FLOAT => Self::Float,
+			ERROR_FLOAT_JUNK_AFTER_POINT => Self::ErrorFloatJunkAfterPoint,
+			ERROR_FLOAT_JUNK_AFTER_EXPONENT => Self::ErrorFloatJunkAfterExponent,
+			ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN => Self::ErrorFloatJunkAfterExponentSign,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl Number {
+	pub fn kind(&self) -> NumberKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for Number {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for ImportKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		ImportKindKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = ImportKindKind::cast(syntax.kind())?;
+		Some(ImportKind { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl ImportKindKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			IMPORTSTR_KW => Self::ImportstrKw,
+			IMPORTBIN_KW => Self::ImportbinKw,
+			IMPORT_KW => Self::ImportKw,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl ImportKind {
+	pub fn kind(&self) -> ImportKindKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for ImportKind {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for Visibility {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		VisibilityKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = VisibilityKind::cast(syntax.kind())?;
+		Some(Visibility { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl VisibilityKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			COLONCOLONCOLON | COLONCOLON | COLON => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			COLONCOLONCOLON => Self::Coloncoloncolon,
+			COLONCOLON => Self::Coloncolon,
+			COLON => Self::Colon,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl Visibility {
+	pub fn kind(&self) -> VisibilityKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for Visibility {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for Trivia {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		TriviaKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = TriviaKind::cast(syntax.kind())?;
+		Some(Trivia { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl TriviaKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			WHITESPACE
+			| MULTI_LINE_COMMENT
+			| ERROR_COMMENT_TOO_SHORT
+			| ERROR_COMMENT_UNTERMINATED
+			| SINGLE_LINE_HASH_COMMENT
+			| SINGLE_LINE_SLASH_COMMENT => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			WHITESPACE => Self::Whitespace,
+			MULTI_LINE_COMMENT => Self::MultiLineComment,
+			ERROR_COMMENT_TOO_SHORT => Self::ErrorCommentTooShort,
+			ERROR_COMMENT_UNTERMINATED => Self::ErrorCommentUnterminated,
+			SINGLE_LINE_HASH_COMMENT => Self::SingleLineHashComment,
+			SINGLE_LINE_SLASH_COMMENT => Self::SingleLineSlashComment,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl Trivia {
+	pub fn kind(&self) -> TriviaKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for Trivia {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl AstToken for CustomError {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		CustomErrorKind::can_cast(kind)
+	}
+	fn cast(syntax: SyntaxToken) -> Option<Self> {
+		let kind = CustomErrorKind::cast(syntax.kind())?;
+		Some(CustomError { syntax, kind })
+	}
+	fn syntax(&self) -> &SyntaxToken {
+		&self.syntax
+	}
+}
+impl CustomErrorKind {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,
+			_ => false,
+		}
+	}
+	pub fn cast(kind: SyntaxKind) -> Option<Self> {
+		let res = match kind {
+			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,
+			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,
+			ERROR_CUSTOM => Self::ErrorCustom,
+			_ => return None,
+		};
+		Some(res)
+	}
+}
+impl CustomError {
+	pub fn kind(&self) -> CustomErrorKind {
+		self.kind
+	}
+}
+impl std::fmt::Display for CustomError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Suffix {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Bind {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Stmt {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ObjBody {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for CompSpec {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprBase {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for MemberComp {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Member {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for FieldName {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Destruct {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructArrayPart {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SourceFile {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Expr {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SuffixIndex {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Name {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SuffixIndexExpr {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SuffixSlice {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SliceDesc {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SuffixApply {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ArgsDesc {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for StmtLocal {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for StmtAssert {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Assertion {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprBinary {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprUnary {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprObjExtend {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprParened {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprLiteral {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprString {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprNumber {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprArray {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprObject {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprArrayComp {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprImport {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprVar {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprIfThenElse {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for TrueExpr {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for FalseExpr {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprFunction {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ParamsDesc {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ExprError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SliceDescEnd {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for SliceDescStep {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Arg {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ObjBodyComp {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ObjBodyMemberList {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for MemberBindStmt {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ObjLocal {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for MemberAssertStmt {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for MemberFieldNormal {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for MemberFieldMethod {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for FieldNameFixed {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for FieldNameDynamic {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for ForSpec {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for IfSpec {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for BindDestruct {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for BindFunction {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for Param {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructFull {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructSkip {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructArray {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructObject {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructObjectField {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructRest {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
+impl std::fmt::Display for DestructArrayElement {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rs
@@ -0,0 +1,293 @@
+//! This is a generated file, please do not edit manually. Changes can be
+//! made in codegeneration that lives in `xtask` top-level dir.
+
+#![allow(
+	bad_style,
+	missing_docs,
+	unreachable_pub,
+	clippy::manual_non_exhaustive,
+	clippy::match_like_matches_macro
+)]
+use logos::Logos;
+#[doc = r" The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT`."]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Logos)]
+#[repr(u16)]
+pub enum SyntaxKind {
+	#[doc(hidden)]
+	TOMBSTONE,
+	#[doc(hidden)]
+	EOF,
+	#[token("||")]
+	OR,
+	#[token("??")]
+	NULL_COAELSE,
+	#[token("&&")]
+	AND,
+	#[token("|")]
+	BIT_OR,
+	#[token("^")]
+	BIT_XOR,
+	#[token("&")]
+	BIT_AND,
+	#[token("==")]
+	EQ,
+	#[token("!=")]
+	NE,
+	#[token("<")]
+	LT,
+	#[token(">")]
+	GT,
+	#[token("<=")]
+	LE,
+	#[token(">=")]
+	GE,
+	#[token("<<")]
+	LHS,
+	#[token(">>")]
+	RHS,
+	#[token("+")]
+	PLUS,
+	#[token("-")]
+	MINUS,
+	#[token("*")]
+	MUL,
+	#[token("/")]
+	DIV,
+	#[token("%")]
+	MODULO,
+	#[token("!")]
+	NOT,
+	#[token("~")]
+	BIT_NOT,
+	#[token("[")]
+	L_BRACK,
+	#[token("]")]
+	R_BRACK,
+	#[token("(")]
+	L_PAREN,
+	#[token(")")]
+	R_PAREN,
+	#[token("{")]
+	L_BRACE,
+	#[token("}")]
+	R_BRACE,
+	#[token(":")]
+	COLON,
+	#[token("::")]
+	COLONCOLON,
+	#[token(":::")]
+	COLONCOLONCOLON,
+	#[token(";")]
+	SEMI,
+	#[token(".")]
+	DOT,
+	#[token("...")]
+	DOTDOTDOT,
+	#[token(",")]
+	COMMA,
+	#[token("$")]
+	DOLLAR,
+	#[token("=")]
+	ASSIGN,
+	#[token("?")]
+	QUESTION_MARK,
+	#[regex("(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?")]
+	FLOAT,
+	#[regex("(?:0|[1-9][0-9]*)\\.[^0-9]")]
+	ERROR_FLOAT_JUNK_AFTER_POINT,
+	#[regex("(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?[eE][^+\\-0-9]")]
+	ERROR_FLOAT_JUNK_AFTER_EXPONENT,
+	#[regex("(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?[eE][+-][^0-9]")]
+	ERROR_FLOAT_JUNK_AFTER_EXPONENT_SIGN,
+	#[regex("\"(?s:[^\"\\\\]|\\\\.)*\"")]
+	STRING_DOUBLE,
+	#[regex("\"(?s:[^\"\\\\]|\\\\.)*")]
+	ERROR_STRING_DOUBLE_UNTERMINATED,
+	#[regex("'(?s:[^'\\\\]|\\\\.)*'")]
+	STRING_SINGLE,
+	#[regex("'(?s:[^'\\\\]|\\\\.)*")]
+	ERROR_STRING_SINGLE_UNTERMINATED,
+	#[regex("@\"(?:[^\"]|\"\")*\"")]
+	STRING_DOUBLE_VERBATIM,
+	#[regex("@\"(?:[^\"]|\"\")*")]
+	ERROR_STRING_DOUBLE_VERBATIM_UNTERMINATED,
+	#[regex("@'(?:[^']|'')*'")]
+	STRING_SINGLE_VERBATIM,
+	#[regex("@'(?:[^']|'')*")]
+	ERROR_STRING_SINGLE_VERBATIM_UNTERMINATED,
+	#[regex("@[^\"'\\s]\\S+")]
+	ERROR_STRING_VERBATIM_MISSING_QUOTES,
+	#[regex("\\|\\|\\|", crate::string_block::lex_str_block_test)]
+	STRING_BLOCK,
+	ERROR_STRING_BLOCK_UNEXPECTED_END,
+	ERROR_STRING_BLOCK_MISSING_NEW_LINE,
+	ERROR_STRING_BLOCK_MISSING_TERMINATION,
+	ERROR_STRING_BLOCK_MISSING_INDENT,
+	#[regex("[_a-zA-Z][_a-zA-Z0-9]*")]
+	IDENT,
+	#[regex("[ \\t\\n\\r]+")]
+	WHITESPACE,
+	#[regex("//[^\\r\\n]*(\\r\\n|\\n)?")]
+	SINGLE_LINE_SLASH_COMMENT,
+	#[regex("#[^\\r\\n]*(\\r\\n|\\n)?")]
+	SINGLE_LINE_HASH_COMMENT,
+	#[regex("/\\*([^*]|\\*[^/])*\\*/")]
+	MULTI_LINE_COMMENT,
+	#[regex("/\\*/")]
+	ERROR_COMMENT_TOO_SHORT,
+	#[regex("/\\*([^*]|\\*[^/])+")]
+	ERROR_COMMENT_UNTERMINATED,
+	#[token("tailstrict")]
+	TAILSTRICT_KW,
+	#[token("local")]
+	LOCAL_KW,
+	#[token("importstr")]
+	IMPORTSTR_KW,
+	#[token("importbin")]
+	IMPORTBIN_KW,
+	#[token("import")]
+	IMPORT_KW,
+	#[token("if")]
+	IF_KW,
+	#[token("then")]
+	THEN_KW,
+	#[token("else")]
+	ELSE_KW,
+	#[token("function")]
+	FUNCTION_KW,
+	#[token("error")]
+	ERROR_KW,
+	#[token("in")]
+	IN_KW,
+	META_OBJECT_APPLY,
+	ERROR_NO_OPERATOR,
+	#[token("null")]
+	NULL_KW,
+	#[token("true")]
+	TRUE_KW,
+	#[token("false")]
+	FALSE_KW,
+	#[token("self")]
+	SELF_KW,
+	#[token("super")]
+	SUPER_KW,
+	#[token("for")]
+	FOR_KW,
+	#[token("assert")]
+	ASSERT_KW,
+	ERROR_MISSING_TOKEN,
+	ERROR_UNEXPECTED_TOKEN,
+	ERROR_CUSTOM,
+	#[doc = r" Also acts as __LAST_TOKEN"]
+	#[error]
+	LEXING_ERROR,
+	SOURCE_FILE,
+	EXPR,
+	SUFFIX_INDEX,
+	NAME,
+	SUFFIX_INDEX_EXPR,
+	SUFFIX_SLICE,
+	SLICE_DESC,
+	SUFFIX_APPLY,
+	ARGS_DESC,
+	STMT_LOCAL,
+	STMT_ASSERT,
+	ASSERTION,
+	EXPR_BINARY,
+	EXPR_UNARY,
+	EXPR_OBJ_EXTEND,
+	EXPR_PARENED,
+	EXPR_LITERAL,
+	EXPR_STRING,
+	EXPR_NUMBER,
+	EXPR_ARRAY,
+	EXPR_OBJECT,
+	EXPR_ARRAY_COMP,
+	EXPR_IMPORT,
+	EXPR_VAR,
+	EXPR_IF_THEN_ELSE,
+	TRUE_EXPR,
+	FALSE_EXPR,
+	EXPR_FUNCTION,
+	PARAMS_DESC,
+	EXPR_ERROR,
+	SLICE_DESC_END,
+	SLICE_DESC_STEP,
+	ARG,
+	OBJ_BODY_COMP,
+	OBJ_BODY_MEMBER_LIST,
+	MEMBER_BIND_STMT,
+	OBJ_LOCAL,
+	MEMBER_ASSERT_STMT,
+	MEMBER_FIELD_NORMAL,
+	MEMBER_FIELD_METHOD,
+	FIELD_NAME_FIXED,
+	FIELD_NAME_DYNAMIC,
+	FOR_SPEC,
+	IF_SPEC,
+	BIND_DESTRUCT,
+	BIND_FUNCTION,
+	PARAM,
+	DESTRUCT_FULL,
+	DESTRUCT_SKIP,
+	DESTRUCT_ARRAY,
+	DESTRUCT_OBJECT,
+	DESTRUCT_OBJECT_FIELD,
+	DESTRUCT_REST,
+	DESTRUCT_ARRAY_ELEMENT,
+	SUFFIX,
+	BIND,
+	STMT,
+	OBJ_BODY,
+	COMP_SPEC,
+	EXPR_BASE,
+	MEMBER_COMP,
+	MEMBER,
+	FIELD_NAME,
+	DESTRUCT,
+	DESTRUCT_ARRAY_PART,
+	BINARY_OPERATOR,
+	UNARY_OPERATOR,
+	LITERAL,
+	TEXT,
+	NUMBER,
+	IMPORT_KIND,
+	VISIBILITY,
+	TRIVIA,
+	CUSTOM_ERROR,
+	#[doc(hidden)]
+	__LAST,
+}
+use self::SyntaxKind::*;
+impl SyntaxKind {
+	pub fn is_keyword(self) -> bool {
+		match self {
+			OR | NULL_COAELSE | AND | BIT_OR | BIT_XOR | BIT_AND | EQ | NE | LT | GT | LE | GE
+			| LHS | RHS | PLUS | MINUS | MUL | DIV | MODULO | NOT | BIT_NOT | L_BRACK | R_BRACK
+			| L_PAREN | R_PAREN | L_BRACE | R_BRACE | COLON | COLONCOLON | COLONCOLONCOLON
+			| SEMI | DOT | DOTDOTDOT | COMMA | DOLLAR | ASSIGN | QUESTION_MARK | TAILSTRICT_KW
+			| LOCAL_KW | IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW | IF_KW | THEN_KW | ELSE_KW
+			| FUNCTION_KW | ERROR_KW | IN_KW | NULL_KW | TRUE_KW | FALSE_KW | SELF_KW
+			| SUPER_KW | FOR_KW | ASSERT_KW => true,
+			_ => false,
+		}
+	}
+	pub fn is_enum(self) -> bool {
+		match self {
+			SUFFIX | BIND | STMT | OBJ_BODY | COMP_SPEC | EXPR_BASE | MEMBER_COMP | MEMBER
+			| FIELD_NAME | DESTRUCT | DESTRUCT_ARRAY_PART | BINARY_OPERATOR | UNARY_OPERATOR
+			| LITERAL | TEXT | NUMBER | IMPORT_KIND | VISIBILITY | TRIVIA | CUSTOM_ERROR => true,
+			_ => false,
+		}
+	}
+	pub fn from_raw(r: u16) -> Self {
+		assert!(r < Self::__LAST as u16);
+		unsafe { std::mem::transmute(r) }
+	}
+	pub fn into_raw(self) -> u16 {
+		self as u16
+	}
+}
+#[macro_export]
+macro_rules ! T { [||] => { $ crate :: SyntaxKind :: OR } ; [??] => { $ crate :: SyntaxKind :: NULL_COAELSE } ; [&&] => { $ crate :: SyntaxKind :: AND } ; [|] => { $ crate :: SyntaxKind :: BIT_OR } ; [^] => { $ crate :: SyntaxKind :: BIT_XOR } ; [&] => { $ crate :: SyntaxKind :: BIT_AND } ; [==] => { $ crate :: SyntaxKind :: EQ } ; [!=] => { $ crate :: SyntaxKind :: NE } ; [<] => { $ crate :: SyntaxKind :: LT } ; [>] => { $ crate :: SyntaxKind :: GT } ; [<=] => { $ crate :: SyntaxKind :: LE } ; [>=] => { $ crate :: SyntaxKind :: GE } ; [<<] => { $ crate :: SyntaxKind :: LHS } ; [>>] => { $ crate :: SyntaxKind :: RHS } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [*] => { $ crate :: SyntaxKind :: MUL } ; [/] => { $ crate :: SyntaxKind :: DIV } ; [%] => { $ crate :: SyntaxKind :: MODULO } ; [!] => { $ crate :: SyntaxKind :: NOT } ; [~] => { $ crate :: SyntaxKind :: BIT_NOT } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_BRACE } ; ['}'] => { $ crate :: SyntaxKind :: R_BRACE } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLONCOLON } ; [:::] => { $ crate :: SyntaxKind :: COLONCOLONCOLON } ; [;] => { $ crate :: SyntaxKind :: SEMI } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [...] => { $ crate :: SyntaxKind :: DOTDOTDOT } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['$'] => { $ crate :: SyntaxKind :: DOLLAR } ; [=] => { $ crate :: SyntaxKind :: ASSIGN } ; [?] => { $ crate :: SyntaxKind :: QUESTION_MARK } ; [tailstrict] => { $ crate :: SyntaxKind :: TAILSTRICT_KW } ; [local] => { $ crate :: SyntaxKind :: LOCAL_KW } ; [importstr] => { $ crate :: SyntaxKind :: IMPORTSTR_KW } ; [importbin] => { $ crate :: SyntaxKind :: IMPORTBIN_KW } ; [import] => { $ crate :: SyntaxKind :: IMPORT_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [then] => { $ crate :: SyntaxKind :: THEN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [function] => { $ crate :: SyntaxKind :: FUNCTION_KW } ; [error] => { $ crate :: SyntaxKind :: ERROR_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [null] => { $ crate :: SyntaxKind :: NULL_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [assert] => { $ crate :: SyntaxKind :: ASSERT_KW } }
+pub use T;

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/language.rs
@@ -0,0 +1,24 @@
+use rowan::Language;
+
+use crate::SyntaxKind;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum JsonnetLanguage {}
+impl Language for JsonnetLanguage {
+	type Kind = SyntaxKind;
+
+	fn kind_from_raw(raw: rowan::SyntaxKind) -> SyntaxKind {
+		SyntaxKind::from_raw(raw.0)
+	}
+
+	fn kind_to_raw(kind: SyntaxKind) -> rowan::SyntaxKind {
+		rowan::SyntaxKind(kind.into_raw())
+	}
+}
+
+pub type SyntaxNode = rowan::SyntaxNode<JsonnetLanguage>;
+pub type SyntaxToken = rowan::SyntaxToken<JsonnetLanguage>;
+pub type SyntaxElement = rowan::SyntaxElement<JsonnetLanguage>;
+pub type SyntaxNodeChildren = rowan::SyntaxNodeChildren<JsonnetLanguage>;
+pub type SyntaxElementChildren = rowan::SyntaxElementChildren<JsonnetLanguage>;
+pub type PreorderWithTokens = rowan::api::PreorderWithTokens<JsonnetLanguage>;

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/lex.rs
@@ -0,0 +1,80 @@
+use core::ops::Range;
+use std::convert::TryFrom;
+
+use logos::Logos;
+use rowan::{TextRange, TextSize};
+
+use crate::{
+	string_block::{lex_str_block, StringBlockError},
+	SyntaxKind,
+};
+
+pub struct Lexer<'a> {
+	inner: logos::Lexer<'a, SyntaxKind>,
+}
+
+impl<'a> Lexer<'a> {
+	pub fn new(input: &'a str) -> Self {
+		Self {
+			inner: SyntaxKind::lexer(input),
+		}
+	}
+}
+
+impl<'a> Iterator for Lexer<'a> {
+	type Item = Lexeme<'a>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		use SyntaxKind::*;
+
+		let mut kind = self.inner.next()?;
+		let text = self.inner.slice();
+
+		if kind == STRING_BLOCK {
+			// We use custom lexer, which skips enough bytes, but not returns error
+			// Instead we should call lexer again to verify if there is something wrong with string block
+			let mut lexer = logos::Lexer::<SyntaxKind>::new(text);
+			// In kinds, string blocks is parsed at least as `|||`
+			lexer.bump(3);
+			let res = lex_str_block(&mut lexer);
+			debug_assert!(lexer.next().is_none(), "str_block is lexed");
+			match res {
+				Ok(_) => {}
+				Err(e) => {
+					kind = match e {
+						StringBlockError::UnexpectedEnd => ERROR_STRING_BLOCK_UNEXPECTED_END,
+						StringBlockError::MissingNewLine => ERROR_STRING_BLOCK_MISSING_NEW_LINE,
+						StringBlockError::MissingTermination => {
+							ERROR_STRING_BLOCK_MISSING_TERMINATION
+						}
+						StringBlockError::MissingIndent => ERROR_STRING_BLOCK_MISSING_INDENT,
+					}
+				}
+			}
+		}
+
+		Some(Self::Item {
+			kind,
+			text,
+			range: {
+				let Range { start, end } = self.inner.span();
+
+				TextRange::new(
+					TextSize::try_from(start).unwrap(),
+					TextSize::try_from(end).unwrap(),
+				)
+			},
+		})
+	}
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct Lexeme<'i> {
+	pub kind: SyntaxKind,
+	pub text: &'i str,
+	pub range: TextRange,
+}
+
+pub fn lex(input: &str) -> Vec<Lexeme<'_>> {
+	Lexer::new(input).collect()
+}

no changes

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/marker.rs
@@ -0,0 +1,187 @@
+use std::num::NonZeroUsize;
+
+use drop_bomb::DropBomb;
+
+use crate::{
+	event::Event,
+	parser::{ExpectedSyntax, Parser, SyntaxError},
+	SyntaxKind,
+};
+
+pub struct Ranger {
+	pub pos: usize,
+}
+impl Ranger {
+	pub fn finish(self, p: &Parser) -> FinishedRanger {
+		FinishedRanger {
+			start_token: self.pos,
+			end_token: self.pos.max(p.offset.saturating_sub(1)),
+		}
+	}
+}
+
+pub struct FinishedRanger {
+	pub start_token: usize,
+	pub end_token: usize,
+}
+impl FinishedRanger {
+	#[allow(dead_code)]
+	pub fn had_error_since(&self, p: &Parser) -> bool {
+		p.last_error_token >= self.start_token
+	}
+}
+
+#[must_use]
+pub struct Marker {
+	pub start_event_idx: usize,
+	bomb: DropBomb,
+}
+impl Marker {
+	pub fn new(pos: usize) -> Self {
+		Self {
+			start_event_idx: pos,
+			bomb: DropBomb::new("marked dropped while not completed"),
+		}
+	}
+	fn complete_raw(
+		mut self,
+		p: &mut Parser,
+		kind: SyntaxKind,
+		error: Option<SyntaxError>,
+	) -> CompletedMarker {
+		self.bomb.defuse();
+		assert!(
+			!kind.is_enum(),
+			"{kind:?} is a enum kind, you should use variant kinds instead"
+		);
+		// TODO: is_lexer should return true if enum variant has #[regex]/#[token] over it, or it is defined as lexer error explicitly
+		// debug_assert!(
+		// 	!kind.is_lexer(),
+		// 	"{kind:?} should be only emitted by lexer, not used directly"
+		// );
+		let event_at_pos = &mut p.events[self.start_event_idx];
+		assert!(matches!(event_at_pos, Event::Pending));
+
+		*event_at_pos = Event::Start {
+			kind,
+			forward_parent: None,
+		};
+
+		let finish_event_idx = p.events.len();
+		p.events.push(Event::Finish {
+			wrapper: None,
+			error: error.map(Box::new),
+		});
+		p.entered -= 1;
+		p.clear_outdated_hints();
+		CompletedMarker {
+			start_event_idx: self.start_event_idx,
+			finish_event_idx,
+		}
+	}
+	pub fn complete(mut self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
+		self.complete_raw(p, kind, None)
+	}
+	pub fn complete_error(mut self, p: &mut Parser, msg: impl AsRef<str>) -> CompletedMarker {
+		self.complete_raw(
+			p,
+			SyntaxKind::ERROR_CUSTOM,
+			Some(SyntaxError::Custom {
+				error: msg.as_ref().to_owned(),
+			}),
+		)
+	}
+	pub fn complete_missing(mut self, p: &mut Parser, expected: ExpectedSyntax) -> CompletedMarker {
+		self.complete_raw(
+			p,
+			SyntaxKind::ERROR_MISSING_TOKEN,
+			Some(SyntaxError::Missing { expected }),
+		)
+	}
+	pub fn complete_unexpected(
+		mut self,
+		p: &mut Parser,
+		expected: ExpectedSyntax,
+		found: SyntaxKind,
+	) -> CompletedMarker {
+		self.complete_raw(
+			p,
+			SyntaxKind::ERROR_UNEXPECTED_TOKEN,
+			Some(SyntaxError::Unexpected { expected, found }),
+		)
+	}
+
+	pub fn forget(mut self, p: &mut Parser) {
+		self.bomb.defuse();
+		let event_at_pos = &mut p.events[self.start_event_idx];
+		assert!(matches!(event_at_pos, Event::Pending));
+
+		*event_at_pos = Event::Noop;
+		p.entered -= 1;
+		p.clear_outdated_hints();
+	}
+}
+pub struct CompletedMarker {
+	start_event_idx: usize,
+	finish_event_idx: usize,
+}
+impl CompletedMarker {
+	pub(super) fn precede(self, p: &mut Parser) -> Marker {
+		let new_m = p.start();
+		match &mut p.events[self.start_event_idx] {
+			Event::Start { forward_parent, .. } => {
+				*forward_parent = Some(
+					NonZeroUsize::new(new_m.start_event_idx - self.start_event_idx).expect("!= 0"),
+				);
+			}
+			_ => unreachable!(),
+		}
+
+		new_m
+	}
+	/// Create new node around existing marker, not counting anything that comes after it
+	fn wrap_raw(
+		self,
+		p: &mut Parser,
+		kind: SyntaxKind,
+		error: Option<SyntaxError>,
+	) -> CompletedMarker {
+		let new_m = p.start();
+		match &mut p.events[self.start_event_idx] {
+			Event::Start { forward_parent, .. } => {
+				*forward_parent = Some(
+					NonZeroUsize::new(new_m.start_event_idx - self.start_event_idx).expect("!= 0"),
+				);
+			}
+			_ => unreachable!(),
+		}
+
+		let completed = new_m.complete_raw(p, kind, error);
+
+		match &mut p.events[self.finish_event_idx] {
+			Event::Finish {
+				wrapper,
+				error: _error,
+			} => {
+				*wrapper = Some(
+					NonZeroUsize::new(completed.finish_event_idx - self.finish_event_idx)
+						.expect("!= 0"),
+				);
+			}
+			_ => unreachable!(),
+		}
+		completed
+	}
+	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
+		self.wrap_raw(p, kind, None)
+	}
+	pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef<str>) -> CompletedMarker {
+		self.wrap_raw(
+			p,
+			SyntaxKind::ERROR_CUSTOM,
+			Some(SyntaxError::Custom {
+				error: msg.as_ref().to_owned(),
+			}),
+		)
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-rowan-parser/src/parser.rs
@@ -0,0 +1,940 @@
+use std::{cell::Cell, fmt, rc::Rc};
+
+use miette::{LabeledSpan, SourceOffset, SourceSpan};
+use rowan::{GreenNode, TextRange};
+
+use crate::{
+	event::Event,
+	marker::{CompletedMarker, Marker, Ranger},
+	nodes::{BinaryOperatorKind, Literal, Number, Text, UnaryOperatorKind},
+	token_set::SyntaxKindSet,
+	AstToken, SyntaxKind,
+	SyntaxKind::*,
+	SyntaxNode, T, TS,
+};
+
+pub struct Parse {
+	pub green_node: GreenNode,
+	pub errors: Vec<LocatedSyntaxError>,
+}
+
+pub struct Parser {
+	// TODO: remove all trivia before feeding to parser?
+	kinds: Vec<SyntaxKind>,
+	pub offset: usize,
+	pub events: Vec<Event>,
+	pub entered: u32,
+	pub hints: Vec<(u32, TextRange, String)>,
+	pub last_error_token: usize,
+	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,
+	steps: Cell<u64>,
+}
+
+#[derive(Clone, Debug)]
+pub enum SyntaxError {
+	Unexpected {
+		expected: ExpectedSyntax,
+		found: SyntaxKind,
+	},
+	Missing {
+		expected: ExpectedSyntax,
+	},
+	Custom {
+		error: String,
+	},
+	Hint {
+		error: String,
+	},
+}
+
+#[derive(Debug)]
+pub struct LocatedSyntaxError {
+	pub error: SyntaxError,
+	pub range: TextRange,
+}
+
+impl From<LocatedSyntaxError> for LabeledSpan {
+	fn from(val: LocatedSyntaxError) -> Self {
+		let span = SourceSpan::new(
+			SourceOffset::from(usize::from(val.range.start())),
+			SourceOffset::from(usize::from(val.range.end() - val.range.start())),
+		);
+		dbg!(&val);
+		match val.error {
+			SyntaxError::Unexpected { expected, found } => LabeledSpan::new_with_span(
+				Some(format!("expected {expected}, found {found:?}")),
+				span,
+			),
+			SyntaxError::Missing { expected } => {
+				LabeledSpan::new_with_span(Some(format!("missing {expected}")), span)
+			}
+			SyntaxError::Custom { error } | SyntaxError::Hint { error } => {
+				LabeledSpan::new_with_span(Some(error), span)
+			}
+		}
+	}
+}
+
+impl Parser {
+	pub fn new(kinds: Vec<SyntaxKind>) -> Self {
+		Self {
+			kinds,
+			offset: 0,
+			events: vec![],
+			entered: 0,
+			last_error_token: 0,
+			hints: vec![],
+			expected_syntax_tracking_state: Rc::new(Cell::new(ExpectedSyntax::Unnamed(TS![]))),
+			steps: Cell::new(0),
+		}
+	}
+	pub fn clear_outdated_hints(&mut self) {
+		let amount = self
+			.hints
+			.iter()
+			.rev()
+			.take_while(|h| h.0 > self.entered)
+			.count();
+		self.hints.truncate(self.hints.len() - amount)
+	}
+	fn clear_expected_syntaxes(&mut self) {
+		self.expected_syntax_tracking_state
+			.set(ExpectedSyntax::Unnamed(TS![]));
+	}
+	pub fn start(&mut self) -> Marker {
+		let start_event_idx = self.events.len();
+		self.events.push(Event::Pending);
+		self.entered += 1;
+		Marker::new(start_event_idx)
+	}
+	pub fn start_ranger(&mut self) -> Ranger {
+		let pos = self.offset;
+		Ranger { pos }
+	}
+	pub fn parse(mut self) -> Vec<Event> {
+		let m = self.start();
+		expr(&mut self);
+		if !self.at(EOF) {
+			let m = self.start();
+			while !self.at(EOF) {
+				self.bump();
+			}
+			m.complete_error(&mut self, "unexpected tokens after end");
+		}
+		m.complete(&mut self, SOURCE_FILE);
+
+		self.events
+	}
+
+	pub(crate) fn expect(&mut self, kind: SyntaxKind) {
+		self.expect_with_recovery_set(kind, TS![])
+	}
+
+	pub(crate) fn expect_with_recovery_set(
+		&mut self,
+		kind: SyntaxKind,
+		recovery_set: SyntaxKindSet,
+	) {
+		if self.at(kind) {
+			if kind != EOF {
+				self.bump();
+			}
+		} else {
+			self.error_with_recovery_set(recovery_set);
+		}
+	}
+
+	pub(crate) fn expect_with_no_skip(&mut self, kind: SyntaxKind) {
+		if self.at(kind) {
+			self.bump();
+		} else {
+			self.error_with_no_skip();
+		}
+	}
+	pub fn error_with_no_skip(&mut self) -> CompletedMarker {
+		self.error_with_recovery_set(SyntaxKindSet::ALL)
+	}
+
+	pub fn error_with_recovery_set(&mut self, recovery_set: SyntaxKindSet) -> CompletedMarker {
+		let expected = self.expected_syntax_tracking_state.get();
+		self.expected_syntax_tracking_state
+			.set(ExpectedSyntax::Unnamed(TS![]));
+
+		if self.at_end() || self.at_ts(recovery_set) {
+			let m = self.start();
+			return m.complete_missing(self, expected);
+		}
+
+		let current_token = self.current();
+
+		self.last_error_token = self.offset;
+
+		let m = self.start();
+		self.bump();
+		let m = m.complete_unexpected(self, expected, current_token);
+		self.clear_expected_syntaxes();
+		m
+	}
+	fn bump_assert(&mut self, kind: SyntaxKind) {
+		assert!(self.at(kind), "expected {:?}", kind);
+		self.bump_remap(self.current());
+	}
+	fn bump(&mut self) {
+		self.bump_remap(self.current());
+	}
+	fn bump_remap(&mut self, kind: SyntaxKind) {
+		assert_ne!(self.offset, self.kinds.len(), "already at end");
+		self.events.push(Event::Token { kind });
+		self.offset += 1;
+		self.clear_expected_syntaxes();
+	}
+	fn step(&self) {
+		use std::fmt::Write;
+		let steps = self.steps.get();
+		if steps >= 15000000 {
+			let mut out = "seems like parsing is stuck".to_owned();
+			{
+				let last = 20;
+				write!(out, "\n\nLast {} events:", last).unwrap();
+				for (i, event) in self
+					.events
+					.iter()
+					.skip(self.events.len().saturating_sub(last))
+					.enumerate()
+				{
+					write!(out, "\n{i}. {event:?}").unwrap();
+				}
+			}
+			{
+				let next = 20;
+				write!(out, "\n\nNext {next} tokens:").unwrap();
+				for (i, tok) in self.kinds.iter().skip(self.offset).take(next).enumerate() {
+					write!(out, "\n{i}. {tok:?}").unwrap();
+				}
+			}
+			panic!("{out}")
+		}
+		self.steps.set(steps + 1);
+	}
+	fn nth(&self, i: usize) -> SyntaxKind {
+		self.step();
+		let mut offset = self.offset;
+		for _ in 0..i {
+			offset += 1;
+		}
+		self.kinds.get(offset).copied().unwrap_or(EOF)
+	}
+	fn current(&self) -> SyntaxKind {
+		self.nth(0)
+	}
+	#[must_use]
+	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {
+		self.expected_syntax_tracking_state
+			.set(ExpectedSyntax::Named(name));
+
+		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))
+	}
+	pub fn at(&mut self, kind: SyntaxKind) -> bool {
+		self.nth_at(0, kind)
+	}
+	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {
+		if n == 0 {
+			if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {
+				let kinds = kinds.with(kind);
+				self.expected_syntax_tracking_state
+					.set(ExpectedSyntax::Unnamed(kinds))
+			}
+		}
+		self.nth(n) == kind
+	}
+	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {
+		if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {
+			let kinds = kinds.union(set);
+			self.expected_syntax_tracking_state
+				.set(ExpectedSyntax::Unnamed(kinds))
+		}
+		set.contains(self.current())
+	}
+	pub fn at_end(&mut self) -> bool {
+		self.at(EOF)
+	}
+}
+pub(crate) struct ExpectedSyntaxGuard {
+	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,
+}
+
+impl ExpectedSyntaxGuard {
+	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>) -> Self {
+		Self {
+			expected_syntax_tracking_state,
+		}
+	}
+}
+
+impl Drop for ExpectedSyntaxGuard {
+	fn drop(&mut self) {
+		self.expected_syntax_tracking_state
+			.set(ExpectedSyntax::Unnamed(TS![]));
+	}
+}
+
+#[derive(Clone, Debug, Copy)]
+pub enum ExpectedSyntax {
+	Named(&'static str),
+	Unnamed(SyntaxKindSet),
+}
+impl fmt::Display for ExpectedSyntax {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			ExpectedSyntax::Named(name) => write!(f, "{name}"),
+			ExpectedSyntax::Unnamed(set) => write!(f, "{set}"),
+		}
+	}
+}
+
+fn expr(p: &mut Parser) -> CompletedMarker {
+	let m = p.start();
+	while p.at(T![local]) || p.at(T![assert]) {
+		let m = p.start();
+
+		if p.at(T![local]) {
+			p.bump();
+			loop {
+				if p.at(T![;]) {
+					p.bump();
+					break;
+				}
+				bind(p);
+
+				if p.at(T![,]) {
+					p.bump();
+					continue;
+				}
+				p.expect(T![;]);
+				break;
+			}
+			m.complete(p, STMT_LOCAL);
+		} else {
+			assertion(p);
+			p.expect(T![;]);
+			m.complete(p, STMT_ASSERT);
+		}
+	}
+	match expr_binding_power(p, 0) {
+		Ok(m) => m,
+		Err(m) => m,
+	};
+	m.complete(p, EXPR)
+}
+fn expr_binding_power(
+	p: &mut Parser,
+	minimum_binding_power: u8,
+) -> Result<CompletedMarker, CompletedMarker> {
+	let mut lhs = lhs(p)?;
+
+	while let Some(op) = BinaryOperatorKind::cast(p.current())
+		.or_else(|| p.at(T!['{']).then_some(BinaryOperatorKind::MetaObjectApply))
+	{
+		let (left_binding_power, right_binding_power) = op.binding_power();
+		if left_binding_power < minimum_binding_power {
+			break;
+		}
+
+		// Object apply is not a real operator, we dont have something to bump
+		if op != BinaryOperatorKind::MetaObjectApply {
+			p.bump();
+		}
+
+		let m = lhs.wrap(p, EXPR).precede(p);
+		let parsed_rhs = expr_binding_power(p, right_binding_power)
+			.map(|v| v.precede(p).complete(p, EXPR))
+			.is_ok();
+		lhs = m.complete(
+			p,
+			if op == BinaryOperatorKind::MetaObjectApply {
+				EXPR_OBJ_EXTEND
+			} else {
+				EXPR_BINARY
+			},
+		);
+
+		if !parsed_rhs {
+			break;
+		}
+	}
+	Ok(lhs)
+}
+
+const COMPSPEC: SyntaxKindSet = TS![for if];
+fn compspec(p: &mut Parser) -> CompletedMarker {
+	assert!(p.at_ts(COMPSPEC));
+	if p.at(T![for]) {
+		let m = p.start();
+		p.bump();
+		destruct(p);
+		p.expect(T![in]);
+		expr(p);
+		m.complete(p, FOR_SPEC)
+	} else if p.at(T![if]) {
+		let m = p.start();
+		p.bump();
+		expr(p);
+		m.complete(p, IF_SPEC)
+	} else {
+		unreachable!()
+	}
+}
+
+fn comma(p: &mut Parser) -> bool {
+	comma_with_alternatives(p, TS![])
+}
+fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {
+	if p.at(T![,]) {
+		p.bump();
+		true
+	} else if p.at_ts(set) {
+		let _ex = p.expected_syntax_name("comma");
+		p.expect_with_recovery_set(T![,], TS![]);
+		true
+	} else {
+		false
+	}
+}
+
+fn field_name(p: &mut Parser) {
+	let _e = p.expected_syntax_name("field name");
+	let m = p.start();
+	if p.at(T!['[']) {
+		p.bump();
+		expr(p);
+		p.expect(T![']']);
+		m.complete(p, FIELD_NAME_DYNAMIC);
+	} else if p.at(IDENT) {
+		name(p);
+		m.complete(p, FIELD_NAME_FIXED);
+	} else if Text::can_cast(p.current()) {
+		text(p);
+		m.complete(p, FIELD_NAME_FIXED);
+	} else {
+		m.forget(p);
+		p.error_with_recovery_set(TS![; : :: ::: '(']);
+	}
+}
+fn visibility(p: &mut Parser) {
+	if p.at_ts(TS![: :: :::]) {
+		p.bump()
+	} else {
+		p.error_with_recovery_set(TS![=]);
+	}
+}
+fn assertion(p: &mut Parser) {
+	let m = p.start();
+	p.bump_assert(T![assert]);
+	expr(p);
+	if p.at(T![:]) {
+		p.bump();
+		expr(p);
+	}
+	m.complete(p, ASSERTION);
+}
+fn object(p: &mut Parser) -> CompletedMarker {
+	let m_t = p.start();
+	let m = p.start();
+	p.bump_assert(T!['{']);
+
+	let mut elems = 0;
+	let mut compspecs = Vec::new();
+	let mut asserts = Vec::new();
+	loop {
+		if p.at(T!['}']) {
+			p.bump();
+			break;
+		}
+		if p.at_ts(COMPSPEC) {
+			if elems == 0 {
+				let m = p.start();
+				m.complete_missing(p, ExpectedSyntax::Named("field definition"));
+			}
+			while p.at_ts(COMPSPEC) {
+				compspecs.push(compspec(p));
+			}
+			if comma_with_alternatives(p, TS![;]) {
+				continue;
+			}
+			p.expect(R_BRACE);
+			break;
+		}
+		let m = p.start();
+		if p.at(T![local]) {
+			obj_local(p);
+			m.complete(p, MEMBER_BIND_STMT);
+		} else if p.at(T![assert]) {
+			assertion(p);
+			asserts.push(m.complete(p, MEMBER_ASSERT_STMT));
+		} else {
+			field_name(p);
+			if p.at(T![+]) {
+				p.bump();
+			}
+			let params = if p.at(T!['(']) {
+				params_desc(p);
+				visibility(p);
+				expr(p);
+				true
+			} else if p.at_ts(TS![: :: :::]) && p.nth_at(1, T![function]) {
+				visibility(p);
+				p.bump_assert(T![function]);
+				params_desc(p);
+				expr(p);
+				true
+			} else {
+				visibility(p);
+				expr(p);
+				false
+			};
+			elems += 1;
+
+			if params {
+				m.complete(p, MEMBER_FIELD_METHOD)
+			} else {
+				m.complete(p, MEMBER_FIELD_NORMAL)
+			};
+		};
+		while p.at_ts(COMPSPEC) {
+			compspecs.push(compspec(p));
+		}
+		if comma_with_alternatives(p, TS![;]) {
+			continue;
+		}
+		p.expect(R_BRACE);
+		break;
+	}
+
+	if elems > 1 && !compspecs.is_empty() {
+		for errored in compspecs {
+			errored.wrap_error(
+				p,
+				"compspec may only be used if there is only one object element",
+			);
+		}
+		m.complete(p, OBJ_BODY_MEMBER_LIST);
+	} else if !compspecs.is_empty() {
+		for errored in asserts {
+			errored.wrap_error(p, "asserts can't be used in object comprehensions");
+		}
+		m.complete(p, OBJ_BODY_COMP);
+	} else {
+		m.complete(p, OBJ_BODY_MEMBER_LIST);
+	}
+	m_t.complete(p, EXPR_OBJECT)
+}
+fn param(p: &mut Parser) {
+	let m = p.start();
+	destruct(p);
+	if p.at(T![=]) {
+		p.bump();
+		expr(p);
+	}
+	m.complete(p, PARAM);
+}
+fn params_desc(p: &mut Parser) -> CompletedMarker {
+	let m = p.start();
+	p.bump_assert(T!['(']);
+
+	loop {
+		if p.at(T![')']) {
+			p.bump();
+			break;
+		}
+		param(p);
+		if comma(p) {
+			continue;
+		}
+		p.expect(T![')']);
+		break;
+	}
+
+	m.complete(p, PARAMS_DESC)
+}
+fn args_desc(p: &mut Parser) {
+	let m = p.start();
+	p.bump_assert(T!['(']);
+
+	let started_named = Cell::new(false);
+	let mut unnamed_after_named = Vec::new();
+
+	loop {
+		if p.at(T![')']) {
+			break;
+		}
+
+		let m = p.start();
+		if p.at(IDENT) && p.nth_at(1, T![=]) {
+			name(p);
+			p.bump();
+			expr(p);
+			m.complete(p, ARG);
+			started_named.set(true);
+		} else {
+			expr(p);
+			let arg = m.complete(p, ARG);
+			if started_named.get() {
+				unnamed_after_named.push(arg)
+			}
+		}
+		if comma(p) {
+			continue;
+		}
+		break;
+	}
+	p.expect(T![')']);
+	if p.at(T![tailstrict]) {
+		p.bump()
+	}
+
+	for errored in unnamed_after_named {
+		errored.wrap_error(p, "can't use positional arguments after named");
+	}
+
+	m.complete(p, ARGS_DESC);
+}
+
+fn array(p: &mut Parser) -> CompletedMarker {
+	// Start the list node
+	let m = p.start();
+	p.bump_assert(T!['[']);
+
+	let mut compspecs = Vec::new();
+	let mut elems = 0;
+
+	loop {
+		if p.at(T![']']) {
+			p.bump();
+			break;
+		}
+		if elems != 0 && p.at_ts(COMPSPEC) {
+			while p.at_ts(COMPSPEC) {
+				compspecs.push(compspec(p));
+			}
+			if comma(p) {
+				continue;
+			}
+			p.expect(T![']']);
+			break;
+		}
+		expr(p);
+		elems += 1;
+		while p.at_ts(COMPSPEC) {
+			compspecs.push(compspec(p));
+		}
+		if comma(p) {
+			continue;
+		}
+		p.expect(T![']']);
+		break;
+	}
+
+	if elems > 1 && !compspecs.is_empty() {
+		for spec in compspecs {
+			spec.wrap_error(
+				p,
+				"compspec may only be used if there is only one array element",
+			);
+		}
+
+		m.complete(p, EXPR_ARRAY)
+	} else if !compspecs.is_empty() {
+		m.complete(p, EXPR_ARRAY_COMP)
+	} else {
+		m.complete(p, EXPR_ARRAY)
+	}
+}
+/// Returns true if it was slice, false if just index
+#[must_use]
+fn slice_desc_or_index(p: &mut Parser) -> bool {
+	let m = p.start();
+	p.bump();
+	// TODO: do not treat :, ::, ::: as full tokens?
+	// Start
+	if !p.at(T![:]) && !p.at(T![::]) {
+		expr(p);
+	}
+	if p.at(T![:]) {
+		p.bump();
+		// End
+		if !p.at(T![']']) {
+			expr(p).wrap(p, SLICE_DESC_END);
+		}
+		if p.at(T![:]) {
+			p.bump();
+			// Step
+			if !p.at(T![']']) {
+				expr(p).wrap(p, SLICE_DESC_STEP);
+			}
+		}
+	} else if p.at(T![::]) {
+		p.bump();
+		// End
+		if !p.at(T![']']) {
+			expr(p).wrap(p, SLICE_DESC_END);
+		}
+	} else {
+		// It was not a slice
+		p.expect(T![']']);
+		m.forget(p);
+		return false;
+	}
+	p.expect(T![']']);
+	m.complete(p, SLICE_DESC);
+	true
+}
+
+fn suffix(p: &mut Parser) {
+	loop {
+		let start = p.start();
+		let _marker: CompletedMarker = if p.at(T![?]) {
+			p.bump();
+			p.expect(T![.]);
+			if p.at(IDENT) {
+				name(p);
+				start.complete(p, SUFFIX_INDEX)
+			} else if p.at(T!['[']) {
+				p.bump();
+				expr(p);
+				p.expect(T![']']);
+				start.complete(p, SUFFIX_INDEX_EXPR)
+			} else {
+				start.complete_missing(p, ExpectedSyntax::Named("index"))
+			}
+		} else if p.at(T![.]) {
+			p.bump();
+			name(p);
+			start.complete(p, SUFFIX_INDEX)
+		} else if p.at(T!['[']) {
+			if slice_desc_or_index(p) {
+				start.complete(p, SUFFIX_SLICE)
+			} else {
+				start.complete(p, SUFFIX_INDEX_EXPR)
+			}
+		} else if p.at(T!['(']) {
+			args_desc(p);
+			start.complete(p, SUFFIX_APPLY)
+		} else {
+			start.forget(p);
+			break;
+		};
+	}
+}
+
+fn lhs(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {
+	let lhs = lhs_basic(p)?;
+
+	suffix(p);
+
+	Ok(lhs)
+}
+fn name(p: &mut Parser) {
+	let m = p.start();
+	p.expect(IDENT);
+	m.complete(p, NAME);
+}
+fn destruct_rest(p: &mut Parser) {
+	let m = p.start();
+	p.bump_assert(T![...]);
+	if p.at(IDENT) {
+		p.bump()
+	}
+	m.complete(p, DESTRUCT_REST);
+}
+fn destruct_object_field(p: &mut Parser) {
+	let m = p.start();
+	name(p);
+	if p.at(T![:]) {
+		p.bump();
+		destruct(p);
+	};
+	if p.at(T![=]) {
+		p.bump();
+		expr(p);
+	}
+	m.complete(p, DESTRUCT_OBJECT_FIELD);
+}
+fn obj_local(p: &mut Parser) {
+	let m = p.start();
+	p.bump_assert(T![local]);
+	bind(p);
+	m.complete(p, OBJ_LOCAL);
+}
+fn destruct(p: &mut Parser) -> CompletedMarker {
+	let m = p.start();
+	let _ex = p.expected_syntax_name("destruction specifier");
+	if p.at(T![?]) {
+		p.bump();
+		m.complete(p, DESTRUCT_SKIP)
+	} else if p.at(T!['[']) {
+		p.bump();
+		let mut had_rest = false;
+		loop {
+			if p.at(T![']']) {
+				p.bump();
+				break;
+			} else if p.at(T![...]) {
+				let m_err = p.start_ranger();
+				destruct_rest(p);
+				// if had_rest {
+				// 	p.custom_error(m_err.finish(p), "only one rest can be present in array");
+				// }
+				had_rest = true;
+			} else {
+				destruct(p);
+			}
+			if p.at(T![,]) {
+				p.bump();
+				continue;
+			}
+			p.expect(T![']']);
+			break;
+		}
+		m.complete(p, DESTRUCT_ARRAY)
+	} else if p.at(T!['{']) {
+		p.bump();
+		let mut had_rest = false;
+		loop {
+			if p.at(T!['}']) {
+				p.bump();
+				break;
+			} else if p.at(T![...]) {
+				let m_err = p.start_ranger();
+				destruct_rest(p);
+				// if had_rest {
+				// 	p.custom_error(m_err.finish(p), "only one rest can be present in object");
+				// }
+				had_rest = true;
+			} else {
+				if had_rest {
+					p.error_with_recovery_set(TS![]);
+				}
+				destruct_object_field(p);
+			}
+			if p.at(T![,]) {
+				p.bump();
+				continue;
+			}
+			p.expect(T!['}']);
+			break;
+		}
+		m.complete(p, DESTRUCT_OBJECT)
+	} else if p.at(IDENT) {
+		name(p);
+		m.complete(p, DESTRUCT_FULL)
+	} else {
+		m.forget(p);
+		p.error_with_recovery_set(TS![; , '}', '(', :])
+	}
+}
+fn bind(p: &mut Parser) {
+	let m = p.start();
+	if p.at(IDENT) && p.nth_at(1, T!['(']) {
+		name(p);
+		params_desc(p);
+		p.expect(T![=]);
+		expr(p);
+		m.complete(p, BIND_FUNCTION)
+	} else if p.at(IDENT) && p.nth_at(1, T![=]) && p.nth_at(2, T![function]) {
+		name(p);
+		p.expect(T![=]);
+		p.expect(T![function]);
+		params_desc(p);
+		expr(p);
+		m.complete(p, BIND_FUNCTION)
+	} else {
+		destruct(p);
+		p.expect(T![=]);
+		expr(p);
+		m.complete(p, BIND_DESTRUCT)
+	};
+}
+fn text(p: &mut Parser) {
+	assert!(Text::can_cast(p.current()));
+	p.bump();
+}
+fn number(p: &mut Parser) {
+	assert!(Number::can_cast(p.current()));
+	p.bump();
+}
+fn literal(p: &mut Parser) {
+	assert!(Literal::can_cast(p.current()));
+	p.bump();
+}
+fn lhs_basic(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {
+	let _e = p.expected_syntax_name("expression");
+	Ok(if Literal::can_cast(p.current()) {
+		let m = p.start();
+		literal(p);
+		m.complete(p, EXPR_LITERAL)
+	} else if Text::can_cast(p.current()) {
+		let m = p.start();
+		text(p);
+		m.complete(p, EXPR_STRING)
+	} else if Number::can_cast(p.current()) {
+		let m = p.start();
+		number(p);
+		m.complete(p, EXPR_NUMBER)
+	} else if p.at(IDENT) {
+		let m = p.start();
+		name(p);
+		m.complete(p, EXPR_VAR)
+	} else if p.at(T![if]) {
+		let m = p.start();
+		p.bump();
+		expr(p);
+		p.expect(T![then]);
+		expr(p).wrap(p, TRUE_EXPR);
+		if p.at(T![else]) {
+			p.bump();
+			expr(p).wrap(p, FALSE_EXPR);
+		}
+		m.complete(p, EXPR_IF_THEN_ELSE)
+	} else if p.at(T!['[']) {
+		array(p)
+	} else if p.at(T!['{']) {
+		object(p)
+	} else if p.at(T![function]) {
+		let m = p.start();
+		p.bump();
+		params_desc(p);
+		expr(p);
+		m.complete(p, EXPR_FUNCTION)
+	} else if p.at(T![error]) {
+		let m = p.start();
+		p.bump();
+		expr(p);
+		m.complete(p, EXPR_ERROR)
+	} else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {
+		let m = p.start();
+		p.bump();
+		text(p);
+		m.complete(p, EXPR_IMPORT)
+	} else if let Some(op) = UnaryOperatorKind::cast(p.current()) {
+		let ((), right_binding_power) = op.binding_power();
+
+		let m = p.start();
+		p.bump();
+		let _ = expr_binding_power(p, right_binding_power);
+		m.complete(p, EXPR_UNARY)
+	} else if p.at(T!['(']) {
+		let m = p.start();
+		p.bump();
+		expr(p);
+		p.expect(T![')']);
+		m.complete(p, EXPR_PARENED)
+	} else {
+		return Err(p.error_with_no_skip());
+	})
+}
+
+impl Parse {
+	pub fn syntax(&self) -> SyntaxNode {
+		SyntaxNode::new_root(self.green_node.clone())
+	}
+}