git.delta.rocks / jrsonnet / refs/commits / 26a3b24cc9cf

3use std::{fmt::Debug, mem};3use std::{fmt::Debug, mem};
44
5use jrsonnet_rowan_parser::{5use jrsonnet_rowan_parser::{
6	nodes::{Trivia, TriviaKind},6	nodes::{CustomError, Trivia, TriviaKind},
7	AstNode, AstToken, SyntaxElement,7	AstNode, AstToken, SyntaxElement, SyntaxNode, TS,
8	SyntaxKind::*,
9	SyntaxNode, TS,
10};8};
119
12pub type ChildTrivia = Vec<Trivia>;10pub type ChildTrivia = Vec<Result<Trivia, String>>;
1311
14/// Node should have no non-trivia tokens before element12/// Node should have no non-trivia tokens before element
15pub fn trivia_before(node: SyntaxNode, end: Option<&SyntaxElement>) -> ChildTrivia {13pub fn trivia_before(node: SyntaxNode, end: Option<&SyntaxElement>) -> ChildTrivia {
20		}18		}
2119
22		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {20		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
23			out.push(trivia);21			out.push(Ok(trivia));
24		} else if end.is_none() {22		} else if CustomError::can_cast(item.kind()) {
23			out.push(Err(item.to_string()));
24		} else if end.is_none() {
25			break;25			break;
26		} else {26		} else {
27			assert!(27			assert!(
28				TS![, ;].contains(item.kind()) || item.kind() == ERROR,28				TS![, ;].contains(item.kind()),
29				"silently eaten token: {:?}",29				"silently eaten token: {:?}",
30				item.kind()30				item.kind()
31			)31			)
46	let mut out = Vec::new();46	let mut out = Vec::new();
47	for item in iter {47	for item in iter {
48		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {48		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
49			out.push(trivia);49			out.push(Ok(trivia));
50		} else {50		} else if CustomError::can_cast(item.kind()) {
51			out.push(Err(item.to_string()))
52		} else {
51			assert!(53			assert!(
52				TS![, ;].contains(item.kind()) || item.kind() == ERROR,54				TS![, ;].contains(item.kind()),
53				"silently eaten token: {:?}",55				"silently eaten token: {:?}",
54				item.kind()56				item.kind()
55			)57			)
74	let mut out = Vec::new();76	let mut out = Vec::new();
75	for item in iter.take_while(|i| Some(i) != end) {77	for item in iter.take_while(|i| Some(i) != end) {
76		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {78		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
77			out.push(trivia);79			out.push(Ok(trivia));
78		} else if loose {80		} else if CustomError::can_cast(item.kind()) {
81			out.push(Err(item.to_string()))
82		} else if loose {
79			break;83			break;
80		} else {84		} else {
81			assert!(85			assert!(
82				TS![, ;].contains(item.kind()) || item.kind() == ERROR,86				TS![, ;].contains(item.kind()),
83				"silently eaten token: {:?}",87				"silently eaten token: {:?}",
84				item.kind()88				item.kind()
85			)89			)
120fn count_newlines_before(tt: &ChildTrivia) -> usize {124fn count_newlines_before(tt: &ChildTrivia) -> usize {
121	let mut nl_count = 0;125	let mut nl_count = 0;
122	for t in tt {126	for t in tt {
127		match t {
123		match t.kind() {128			Ok(t) => match t.kind() {
124			TriviaKind::Whitespace => {129				TriviaKind::Whitespace => {
125				nl_count += t.text().bytes().filter(|b| *b == b'\n').count();130					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
126			}131				}
127			_ => break,132				_ => break,
128		}133			},
134			Err(_) => {
135				nl_count += 1;
136			}
137		}
129	}138	}
130	nl_count139	nl_count
131}140}
132fn count_newlines_after(tt: &ChildTrivia) -> usize {141fn count_newlines_after(tt: &ChildTrivia) -> usize {
133	let mut nl_count = 0;142	let mut nl_count = 0;
134	for t in tt.iter().rev() {143	for t in tt.iter().rev() {
144		match t {
135		match t.kind() {145			Ok(t) => match t.kind() {
136			TriviaKind::Whitespace => {146				TriviaKind::Whitespace => {
137				nl_count += t.text().bytes().filter(|b| *b == b'\n').count();147					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
138			}148				}
145				break;155					break;
146			}156				}
147			_ => {}157				_ => {}
148		}158			},
159			Err(_) => nl_count += 1,
160		}
149	}161	}
150	nl_count162	nl_count
151}163}
187				|| current_child.is_none()199				|| current_child.is_none()
188				|| trivia.text().contains('\n') && !is_single_line_comment200				|| trivia.text().contains('\n') && !is_single_line_comment
189			{201			{
190				next.push(trivia.clone());202				next.push(Ok(trivia.clone()));
191				started_next = true;203				started_next = true;
192			} else {204			} else {
193				let cur = current_child.as_mut().expect("checked not none");205				let cur = current_child.as_mut().expect("checked not none");
194				cur.inline_trivia.push(trivia);206				cur.inline_trivia.push(Ok(trivia));
195				if is_single_line_comment {207				if is_single_line_comment {
196					started_next = true;208					started_next = true;
197				}209				}
198			}210			}
199			had_some = true;211			had_some = true;
200		} else if loose {212		} else if CustomError::can_cast(item.kind()) {
213			next.push(Err(item.to_string()))
214		} else if loose {
201			if had_some {215			if had_some {
202				break;216				break;
203			}217			}
204			started_next = true;218			started_next = true;
205		} else {219		} else {
206			assert!(220			assert!(
207				TS![, ;].contains(item.kind()) || item.kind() == ERROR,221				TS![, ;].contains(item.kind()),
208				"silently eaten token: {:?}",222				"silently eaten token: {:?}",
209				item.kind()223				item.kind()
210			)224			)

17	let mut pi = p!(new:);17	let mut pi = p!(new:);
1818
19	for c in comments {19	for c in comments {
20		let Ok(c) = c else {
21			let mut text = c.as_ref().unwrap_err() as &str;
22			while !text.is_empty() {
23				let pos = text.find(|c| c == '\n' || c == '\t').unwrap_or(text.len());
24				let sliced = &text[..pos];
25				p!(pi: string(sliced.to_string()));
26				text = &text[pos..];
27				if! text.is_empty(){
28					match text.as_bytes()[0] {
29						b'\n' => p!(pi: nl),
30						b'\t' => p!(pi: tab),
31						_ => unreachable!()
32					}
33					text = &text[1..];
34				}
35			}
36			continue;
37		};
20		match c.kind() {38		match c.kind() {
21			TriviaKind::Whitespace => {}39			TriviaKind::Whitespace => {}
22			TriviaKind::MultiLineComment => {40			TriviaKind::MultiLineComment => {
37				let mut immediate_start = true;55				let mut immediate_start = true;
38				let mut lines = text56				let mut lines = text
39					.split('\n')57					.split('\n')
40					.map(|l| l.trim_end())58					.map(|l| l.trim_end().to_string())
41					.skip_while(|l| {59					.skip_while(|l| {
42						if l.is_empty() {60						if l.is_empty() {
43							immediate_start = false;61							immediate_start = false;
51					lines.pop();69					lines.pop();
52				}70				}
53				if lines.len() == 1 && !doc {71				if lines.len() == 1 && !doc {
54					p!(pi: str("/* ") str(lines[0].trim()) str(" */") nl)72					p!(pi: str("/* ") string(lines[0].trim().to_string()) str(" */") nl)
55				} else if !lines.is_empty() {73				} else if !lines.is_empty() {
56					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {74					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {
57						let offset = a75						let offset = a
62						&a[..offset]80						&a[..offset]
63					}81					}
64					// First line is not empty, extract ws prefix of it82					// First line is not empty, extract ws prefix of it
65					let mut common_ws_padding = if immediate_start && lines.len() > 1 {83					let mut common_ws_padding = (if immediate_start && lines.len() > 1 {
66						common_ws_prefix(lines[1], lines[1])84						common_ws_prefix(&lines[1], &lines[1])
67					} else {85					} else {
68						common_ws_prefix(lines[0], lines[0])86						common_ws_prefix(&lines[0], &lines[0])
69					};87					})
88					.to_string();
70					for line in lines89					for line in lines
71						.iter()90						.iter()
72						.skip(if immediate_start { 2 } else { 1 })91						.skip(if immediate_start { 2 } else { 1 })
73						.filter(|l| !l.is_empty())92						.filter(|l| !l.is_empty())
74					{93					{
75						common_ws_padding = common_ws_prefix(common_ws_padding, line);94						common_ws_padding = common_ws_prefix(&common_ws_padding, line).to_string();
76					}95					}
77					for line in lines96					for line in lines
78						.iter_mut()97						.iter_mut()
79						.skip(if immediate_start { 1 } else { 0 })98						.skip(if immediate_start { 1 } else { 0 })
80						.filter(|l| !l.is_empty())99						.filter(|l| !l.is_empty())
81					{100					{
82						*line = line101						*line = line
83							.strip_prefix(common_ws_padding)102							.strip_prefix(&common_ws_padding)
103							.expect("all non-empty lines start with this padding")
84							.expect("all non-empty lines start with this padding");104							.to_string();
85					}105					}
86106
87					p!(pi: str("/*"));107					p!(pi: str("/*"));
105								} else {125								} else {
106									p!(pi: tab);126									p!(pi: tab);
107								}127								}
108								line = new_line;128								line = new_line.to_string();
109							}129							}
110							p!(pi: str(line) nl)130							p!(pi: string(line.to_string()) nl)
111						}131						}
112					}132					}
113					if doc {133					if doc {
136				if matches!(loc, CommentLocation::ItemInline) {156				if matches!(loc, CommentLocation::ItemInline) {
137					p!(pi: str(" "))157					p!(pi: str(" "))
138				}158				}
139				p!(pi: str("# ") str(c.text().strip_prefix('#').expect("hash comment starts with #").trim()));159				p!(pi: str("# ") string(c.text().strip_prefix('#').expect("hash comment starts with #").trim().to_string()));
140				if !matches!(loc, CommentLocation::ItemInline) {160				if !matches!(loc, CommentLocation::ItemInline) {
141					p!(pi: nl)161					p!(pi: nl)
142				}162				}
145				if matches!(loc, CommentLocation::ItemInline) {165				if matches!(loc, CommentLocation::ItemInline) {
146					p!(pi: str(" "))166					p!(pi: str(" "))
147				}167				}
148				p!(pi: str("// ") str(c.text().strip_prefix("//").expect("comment starts with //").trim()));168				p!(pi: str("// ") string(c.text().strip_prefix("//").expect("comment starts with //").trim().to_string()));
149				if !matches!(loc, CommentLocation::ItemInline) {169				if !matches!(loc, CommentLocation::ItemInline) {
150					p!(pi: nl)170					p!(pi: nl)
151				}171				}
152			}172			}
153			// Garbage in - garbage out173			// Garbage in - garbage out
154			TriviaKind::ErrorCommentTooShort => p!(pi: str("/*/")),174			TriviaKind::ErrorCommentTooShort => p!(pi: str("/*/")),
155			TriviaKind::ErrorCommentUnterminated => p!(pi: str(c.text())),175			TriviaKind::ErrorCommentUnterminated => p!(pi: string(c.text().to_string())),
156		}176		}
157	}177	}
158178

5use jrsonnet_rowan_parser::{5use jrsonnet_rowan_parser::{
6	nodes::{6	nodes::{
7		ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,7		ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,
8		DestructRest, Expr, Field, FieldName, ForSpec, IfSpec, ImportKind, LhsExpr, Literal,8		DestructRest, Expr, FieldName, ForSpec, IfSpec, ImportKind, LhsExpr, Literal, Member, Name,
9		Member, Name, Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Text,9		Number, ObjBody, ObjLocal, ParamsDesc, SliceDesc, SourceFile, Text, UnaryOperator,
10		UnaryOperator,10		Visibility, VisibilityKind,
11	},11	},
12	rowan::NodeOrToken,
12	AstNode, AstToken, SyntaxToken,13	AstNode, AstToken, SyntaxToken,
13};14};
1415
37		$o.push_str($e);38		$o.push_str($e);
38		pi!(@s; $o: $($t)*);39		pi!(@s; $o: $($t)*);
39	}};40	}};
41	(@s; $o:ident: string($e:expr $(,)?) $($t:tt)*) => {{
42		$o.push_string($e);
43		pi!(@s; $o: $($t)*);
44	}};
40	(@s; $o:ident: nl $($t:tt)*) => {{45	(@s; $o:ident: nl $($t:tt)*) => {{
41		$o.push_signal(dprint_core::formatting::Signal::NewLine);46		$o.push_signal(dprint_core::formatting::Signal::NewLine);
42		pi!(@s; $o: $($t)*);47		pi!(@s; $o: $($t)*);
96		if let Some(v) = self {101		if let Some(v) = self {
97			v.print()102			v.print()
98		} else {103		} else {
99			p!(new: str(104			p!(new: string(
100				&format!(105				format!(
101					"/*missing {}*/",106					"/*missing {}*/",
102					type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")107					type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")
103				),108				),
108113
109impl Printable for SyntaxToken {114impl Printable for SyntaxToken {
110	fn print(&self) -> PrintItems {115	fn print(&self) -> PrintItems {
111		p!(new: str(&self.to_string()))116		p!(new: string(self.to_string()))
112	}117	}
113}118}
114119
115impl Printable for Text {120impl Printable for Text {
116	fn print(&self) -> PrintItems {121	fn print(&self) -> PrintItems {
117		p!(new: str(&format!("{}", self)))122		p!(new: string(format!("{}", self)))
118	}123	}
119}124}
120impl Printable for Number {125impl Printable for Number {
121	fn print(&self) -> PrintItems {126	fn print(&self) -> PrintItems {
122		p!(new: str(&format!("{}", self)))127		p!(new: string(format!("{}", self)))
123	}128	}
124}129}
125130
202	}207	}
203}208}
209
204impl Printable for Field {210impl Printable for Visibility {
205	fn print(&self) -> PrintItems {211	fn print(&self) -> PrintItems {
206		let mut pi = p!(new:);
207		match self {
208			Field::FieldNormal(n) => {
209				p!(pi: {n.field_name()});212		p!(new: string(self.to_string()))
210				if n.plus_token().is_some() {
211					p!(pi: str("+"));
212				}
213				p!(pi: str(": ") {n.expr()});
214			}
215			Field::FieldMethod(m) => {
216				p!(pi: {m.field_name()} {m.params_desc()} str(": ") {m.expr()});
217			}
218		}
219		pi
220	}213	}
221}214}
222215
282	}275	}
283}276}
277
278impl Printable for Member {
279	fn print(&self) -> PrintItems {
280		match self {
281			Member::MemberBindStmt(b) => {
282				p!(new: {b.obj_local()})
283			}
284			Member::MemberAssertStmt(ass) => {
285				p!(new: {ass.assertion()})
286			}
287			Member::MemberFieldNormal(n) => {
288				p!(new: {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()})
289			}
290			Member::MemberFieldMethod(_) => todo!(),
291		}
292	}
293}
284294
285impl Printable for ObjBody {295impl Printable for ObjBody {
286	fn print(&self) -> PrintItems {296	fn print(&self) -> PrintItems {
287		match self {297		match self {
288			ObjBody::ObjBodyComp(_) => todo!(),298			ObjBody::ObjBodyComp(l) => {
299				let mut pi = p!(new: str("{") >i nl);
300				let (children, end_comments) = children_between::<Member>(
301					l.syntax().clone(),
302					l.l_brace_token().map(Into::into).as_ref(),
303					Some(
304						&(l.comp_specs()
305							.next()
306							.expect("at least one spec is defined")
307							.syntax()
308							.clone())
309						.into(),
310					),
311				);
312				for mem in children.into_iter() {
313					if mem.should_start_with_newline {
314						p!(pi: nl);
315					}
316					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));
317					p!(pi: {mem.value} str(","));
318					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));
319					p!(pi: nl)
320				}
321
322				if end_comments.should_start_with_newline {
323					p!(pi: nl);
324				}
325				p!(pi: items(format_comments(&end_comments.trivia, CommentLocation::EndOfItems)));
326
327				let (compspecs, end_comments) = children_between::<CompSpec>(
328					l.syntax().clone(),
329					l.member_comps()
330						.last()
331						.map(|m| m.syntax().clone())
332						.map(Into::into)
333						.or_else(|| l.l_brace_token().map(Into::into))
334						.as_ref(),
335					l.r_brace_token().map(Into::into).as_ref(),
336				);
337				for mem in compspecs.into_iter() {
338					if mem.should_start_with_newline {
339						p!(pi: nl);
340					}
341					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));
342					p!(pi: {mem.value});
343					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));
344					p!(pi: nl)
345				}
346				if end_comments.should_start_with_newline {
347					p!(pi: nl);
348				}
349				p!(pi: items(format_comments(&end_comments.trivia, CommentLocation::EndOfItems)));
350
351				p!(pi: <i str("}"));
352				pi
353			}
289			ObjBody::ObjBodyMemberList(l) => {354			ObjBody::ObjBodyMemberList(l) => {
290				let mut pi = p!(new: str("{") >i nl);355				let mut pi = p!(new: str("{") >i nl);
291				let (children, end_comments) = children_between::<Member>(356				let (children, end_comments) = children_between::<Member>(
298						p!(pi: nl);363						p!(pi: nl);
299					}364					}
300					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));365					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));
301					match mem.value {
302						Member::MemberBindStmt(b) => {
303							p!(pi: {b.obj_local()})
304						}
305						Member::MemberAssertStmt(ass) => {
306							p!(pi: {ass.assertion()})
307						}
308						Member::MemberField(f) => {
309							p!(pi: {f.field()})
310						}
311					}
312					p!(pi: str(","));366					p!(pi: {mem.value} str(","));
313					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));367					p!(pi: items(format_comments(&mem.inline_trivia, CommentLocation::ItemInline)));
314					p!(pi: nl)368					p!(pi: nl)
315				}369				}
326}380}
327impl Printable for UnaryOperator {381impl Printable for UnaryOperator {
328	fn print(&self) -> PrintItems {382	fn print(&self) -> PrintItems {
329		p!(new: str(self.text()))383		p!(new: string(self.text().to_string()))
330	}384	}
331}385}
332impl Printable for BinaryOperator {386impl Printable for BinaryOperator {
333	fn print(&self) -> PrintItems {387	fn print(&self) -> PrintItems {
334		p!(new: str(self.text()))388		p!(new: string(self.text().to_string()))
335	}389	}
336}390}
337impl Printable for Bind {391impl Printable for Bind {
348}402}
349impl Printable for Literal {403impl Printable for Literal {
350	fn print(&self) -> PrintItems {404	fn print(&self) -> PrintItems {
351		p!(new: str(&self.syntax().to_string()))405		p!(new: string(self.syntax().to_string()))
352	}406	}
353}407}
354impl Printable for ImportKind {408impl Printable for ImportKind {
355	fn print(&self) -> PrintItems {409	fn print(&self) -> PrintItems {
356		p!(new: str(&self.syntax().to_string()))410		p!(new: string(self.syntax().to_string()))
357	}411	}
358}412}
359impl Printable for LhsExpr {413impl Printable for LhsExpr {
406			Expr::ExprParened(p) => {460			Expr::ExprParened(p) => {
407				p!(new: str("(") {p.expr()} str(")"))461				p!(new: str("(") {p.expr()} str(")"))
408			}462			}
409			Expr::ExprIntrinsicThisFile(_) => p!(new: str("$intrinsicThisFile")),
410			Expr::ExprIntrinsicId(_) => p!(new: str("$intrinsicId")),
411			Expr::ExprIntrinsic(i) => p!(new: str("$intrinsic(") {i.name()} str(")")),
412			Expr::ExprString(s) => p!(new: {s.text()}),463			Expr::ExprString(s) => p!(new: {s.text()}),
413			Expr::ExprNumber(n) => p!(new: {n.number()}),464			Expr::ExprNumber(n) => p!(new: {n.number()}),
414			Expr::ExprArray(a) => {465			Expr::ExprArray(a) => {
524575
525fn main() {576fn main() {
526	let (parsed, _errors) = jrsonnet_rowan_parser::parse(577	let (parsed, _errors) = jrsonnet_rowan_parser::parse(
527		r#"578		r#"
528579
529580
530		# Edit me!581		# Edit me!
531		local b = import "b.libsonnet";  # comment582		local b = import "b.libsonnet";  # comment
532		local a = import "a.libsonnet";583		local a = import "a.libsonnet";
533584
534			 local f(x,y)=x+y;585			 local f(x,y)=x+y;
535586
536		local {a: [b, ..., c], d, ...e} = null;587		local {a: [b, ..., c], d, ...e} = null;
537588
538		local ass = assert false : false; false;589		local ass = assert false : false; false;
539590
540		local fn = function(a, b, c = 3) 4;591		local fn = function(a, b, c = 3) 4;
541592
542		local comp = [a for b in c if d == e];593		local comp = [a for b in c if d == e];
543		local ocomp = {[k]: 1 for k in v};594		local ocomp = {[k]: 1 for k in v};
544595
545		local ? = skip;596		local ? = skip;
546597
547		local intr = $intrinsic(test);598		local ie = a[expr];
548		local intrId = $intrinsicId;
549		local intrThisFile = $intrinsicThisFile;
550
551		local ie = a[expr];599
552600		local unary = !a;
553		local unary = !a;601
554602		local
555		local603			//   I am comment
556			//   I am comment604			singleLocalWithItemComment = 1,
557			singleLocalWithItemComment = 1,605		;
558		;606
559607		// Comment between local and expression
560		// Comment between local and expression608
561609		local
562		local610			a = 1, //   Inline
563			a = 1, //   Inline611			// Comment above b
564			// Comment above b612			b = 4,
565			b = 4,613
566614			// c needs some space
567			// c needs some space615			c = 5,
568			c = 5,616
569617			// Comment after everything
570			// Comment after everything618		;
571		;619
572620
573621		local Template = {z: "foo"};
574		local Template = {z: "foo"};622
575623		{
576		{624						local
577						local625
578626					h = 3,
579					h = 3,627					assert self.a == 1
580					assert self.a == 1628
581629					: "error",
582					: "error",630		"f": ((((((3)))))) ,
583		"f": ((((((3)))))) ,631		"g g":
584		"g g":632		f(4,2),
585		f(4,2),633		arr: [[
586		arr: [[634		  1, 2,
587		  1, 2,635		  ],
588		  ],636		  3,
589		  3,637		  {
590		  {638			  b: {
591			  b: {639				  c: {
592				  c: {640					  k: [16]
593					  k: [16]641				  }
594				  }642			  }
595			  }643		  }
596		  }644		  ],
597		  ],645		  m: a[1::],
598		  m: a[1::],646		  m: b[::],
599		  m: b[::],647
600648		  comments: {
601		  comments: {649			_: '',
602			_: '',650			//     Plain comment
603			//     Plain comment651			a: '',
604			a: '',652
605653			#    Plain comment with empty line before
606			#    Plain comment with empty line before654			b: '',
607			b: '',655			/*Single-line multiline comment
608			/*Single-line multiline comment656
609657			*/
610			*/658			c: '',
611			c: '',659
612660			/**Single-line multiline doc comment
613			/**Single-line multiline doc comment661
614662			*/
615			*/663			c: '',
616			c: '',664
617665			/**multiline doc comment
618			/**multiline doc comment666			s
619			s667			*/
620			*/668			c: '',
621			c: '',669
622670			/*
623			/*671
624672	Multi-line
625	Multi-line673
626674	comment
627	comment675			*/
628			*/676			d: '',
629			d: '',677
630678			e: '', // Inline comment
631			e: '', // Inline comment679
632680			k: '',
633			k: '',681
634682			// Text after everything
635			// Text after everything683		  },
636		  },684		  comments2: {
637		  comments2: {685			k: '',
638			k: '',686			// Text after everything, but no newline above
639			// Text after everything, but no newline above687		  },
640		  },688		  k: if a         == b    then
641		  k: if a         == b    then689
642690
643691		  2
644		  2692
645693		  else Template {},
694
695		  compspecs: {
696			obj_with_no_item: {for i in [1, 2, 3]},
697			obj_with_2_items: {a:1, b:2, for i in [1,2,3]},
698		  }
646		  else Template {}699
647		} + Template700		} + Template
648701
649702
650		// Comment after everything703		// Comment after everything
651"#,704"#,
652	);705	);
653706
654	// dbg!(errors);707	// dbg!(errors);

3838
39ExprLiteral =39ExprLiteral =
40    Literal40    Literal
41ExprIntrinsicThisFile =
42    '$intrinsicThisFile'
43ExprIntrinsicId =
44    '$intrinsicId'
45ExprIntrinsic =
46    '$intrinsic'
47    '('
48    name:Name
49    ')'
50ExprString =41ExprString =
51    Text42    Text
52ExprNumber =43ExprNumber =
110|   ExprApply101|   ExprApply
111|   ExprObjExtend102|   ExprObjExtend
112|   ExprParened103|   ExprParened
113|   ExprIntrinsicThisFile
114|   ExprIntrinsicId
115|   ExprIntrinsic
116|   ExprString104|   ExprString
117|   ExprNumber105|   ExprNumber
118|   ExprLiteral106|   ExprLiteral
167155
168ObjBodyComp =156ObjBodyComp =
169    '{'157    '{'
170    pre:ObjLocalPostComma*158    (MemberComp (',' MemberComp)* ','?)?
171    '['
172    key:LhsExpr
173    ']'
174    '+'?
175    ':'
176    value:Expr
177    post:ObjLocalPreComma*
178    CompSpec*159    CompSpec*
179    '}'160    '}'
180ObjBodyMemberList =161ObjBodyMemberList =
185    ObjBodyComp166    ObjBodyComp
186|   ObjBodyMemberList167|   ObjBodyMemberList
187168
188ObjLocalPostComma =
189    ObjLocal
190    ','
191ObjLocalPreComma =
192    ','
193    ObjLocal
194
195MemberBindStmt = ObjLocal169MemberBindStmt = ObjLocal
196MemberAssertStmt = Assertion170MemberAssertStmt = Assertion
197MemberFieldNormal =171MemberFieldNormal =
204    ParamsDesc178    ParamsDesc
205    Visibility179    Visibility
206    Expr180    Expr
181MemberComp =
182    MemberBindStmt
183|    MemberFieldNormal
184|   MemberFieldMethod
207Member =185Member =
208    MemberBindStmt186    MemberBindStmt
209|   MemberAssertStmt187|   MemberAssertStmt
367|   'LIT_SINGLE_LINE_HASH_COMMENT!'345|   'LIT_SINGLE_LINE_HASH_COMMENT!'
368|   'LIT_SINGLE_LINE_SLASH_COMMENT!'346|   'LIT_SINGLE_LINE_SLASH_COMMENT!'
369347
370ParsingError =348CustomError =
371    'ERROR_MISSING_TOKEN!'349    'ERROR_MISSING_TOKEN!'
372|   'ERROR_UNEXPECTED_TOKEN!'350|   'ERROR_UNEXPECTED_TOKEN!'
373|   'ERROR_CUSTOM!'351|   'ERROR_CUSTOM!'