git.delta.rocks / jrsonnet / refs/commits / c678cf8e698f

1[workspace]1[workspace]
2package.version = "0.5.0-pre95"2package.version = "0.5.0-pre95"
3package.repository = "https://github.com/CertainLach/jrsonnet"3package.repository = "https://github.com/CertainLach/jrsonnet"
4members = ["crates/*", "bindings/jsonnet", "cmds/*", "tests"]4members = ["crates/*", "bindings/jsonnet", "cmds/*", "tests", "xtask"]
5default-members = ["cmds/jrsonnet"]5default-members = ["cmds/jrsonnet"]
6resolver = "2"6resolver = "2"
77

18backtrace = "0.3.63"18backtrace = "0.3.63"
19indoc = "1.0.3"19indoc = "1.0.3"
20insta = "1.10.0"20insta = "1.10.0"
21anyhow = "1.0.57"
2122

3use rowan::{GreenNode, GreenNodeBuilder, Language};3use rowan::{GreenNode, GreenNodeBuilder, Language};
44
5use crate::{5use crate::{
6	lex::{Lang, Lexeme, SyntaxKind},6	lex::Lexeme,
7	parser::{Parse, SyntaxError},7	parser::{Parse, SyntaxError},
8	JsonnetLanguage, SyntaxKind,
8};9};
910
10#[derive(Clone, Debug, PartialEq, Eq)]11#[derive(Clone, Debug, PartialEq, Eq)]
69					}70					}
7071
71					for kind in kinds.into_iter().rev() {72					for kind in kinds.into_iter().rev() {
72						self.builder.start_node(Lang::kind_to_raw(kind));73						self.builder.start_node(JsonnetLanguage::kind_to_raw(kind));
73					}74					}
74				}75				}
75				Event::Token => self.token(),76				Event::Token => self.token(),
92	fn token(&mut self) {93	fn token(&mut self) {
93		let lexeme = self.lexemes[self.offset];94		let lexeme = self.lexemes[self.offset];
94		self.builder95		self.builder
95			.token(Lang::kind_to_raw(lexeme.kind), lexeme.text);96			.token(JsonnetLanguage::kind_to_raw(lexeme.kind), lexeme.text);
96		self.offset += 1;97		self.offset += 1;
97	}98	}
98	fn skip_whitespace(&mut self) {99	fn skip_whitespace(&mut self) {

1use crate::string_block::lex_str_block_test;1use core::ops::Range;
2use core::ops::Range;2use std::convert::TryFrom;
3
3use logos::Logos;4use logos::Logos;
4use rowan::{Checkpoint, TextRange, TextSize};5use rowan::{TextRange, TextSize};
6
5use std::{convert::TryFrom, iter::Peekable};7use crate::SyntaxKind;
6
7#[derive(Logos, Debug, PartialEq, Hash, Eq, PartialOrd, Ord, Clone, Copy)]
8#[repr(u16)]
9pub enum SyntaxKind {
10	#[token("assert")]
11	KeywordAssert = 0,
12
13	#[token("else")]
14	KeywordElse,
15
16	#[token("error")]
17	KeywordError,
18
19	#[token("false")]
20	KeywordFalse,
21
22	#[token("for")]
23	KeywordFor,
24
25	#[token("function")]
26	KeywordFunction,
27
28	#[token("if")]
29	KeywordIf,
30
31	#[token("import")]
32	KeywordImport,
33
34	#[token("importstr")]
35	KeywordImportStr,
36
37	#[token("local")]
38	KeywordLocal,
39
40	#[token("null")]
41	KeywordNull,
42
43	#[token("tailstrict")]
44	KeywordTailStrict,
45
46	#[token("then")]
47	KeywordThen,
48
49	#[token("self")]
50	KeywordSelf,
51
52	#[token("super")]
53	KeywordSuper,
54
55	#[token("true")]
56	KeywordTrue,
57
58	#[regex(r"[_a-zA-Z][_a-zA-Z0-9]*")]
59	Ident,
60
61	#[regex(r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?")]
62	Number,
63
64	#[regex(r"(?:0|[1-9][0-9]*)\.[^0-9]")]
65	ErrorNumJunkAfterDecimalPoint,
66
67	#[regex(r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?[eE][^+\-0-9]")]
68	ErrorNumJunkAfterExponent,
69
70	#[regex(r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?[eE][+-][^0-9]")]
71	ErrorNumJunkAfterExponentSign,
72
73	#[token("{")]
74	SymbolLeftBrace,
75
76	#[token("}")]
77	SymbolRightBrace,
78
79	#[token("[")]
80	SymbolLeftBracket,
81
82	#[token("]")]
83	SymbolRightBracket,
84
85	#[token(",")]
86	SymbolComma,
87
88	#[token(".")]
89	SymbolDot,
90
91	#[token("(")]
92	LParen,
93
94	#[token(")")]
95	RParen,
96
97	#[token(";")]
98	SymbolSemi,
99	#[token(":")]
100	SymbolColon,
101
102	#[token("$")]
103	SymbolDollar,
104
105	#[token("*")]
106	OpMul,
107	#[token("/")]
108	OpDiv,
109	#[token("%")]
110	OpMod,
111	#[token("+")]
112	OpPlus,
113	#[token("-")]
114	OpMinus,
115	#[token("<<")]
116	OpShiftLeft,
117	#[token(">>")]
118	OpShiftRight,
119	#[token("<")]
120	OpLessThan,
121	#[token(">")]
122	OpGreaterThan,
123	#[token("<=")]
124	OpLessThanOrEqual,
125	#[token(">=")]
126	OpGreaterThanOrEqual,
127	#[token("==")]
128	OpEqual,
129	#[token("!=")]
130	OpNotEqual,
131	#[token("&")]
132	OpBitAnd,
133	#[token("^")]
134	OpBitXor,
135	#[token("|")]
136	OpBitOr,
137	#[token("&&")]
138	OpAnd,
139	#[token("||")]
140	OpOr,
141	#[token("in")]
142	OpIn,
143	#[token("!")]
144	OpNot,
145	#[token("~")]
146	OpBitNegate,
147	#[token("=")]
148	SymbolAssign,
149
150	#[regex("\"(?s:[^\"\\\\]|\\\\.)*\"")]
151	StringDoubleQuoted,
152
153	#[regex("'(?s:[^'\\\\]|\\\\.)*'")]
154	StringSingleQuoted,
155
156	#[regex("@\"(?:[^\"]|\"\")*\"")]
157	StringDoubleVerbatim,
158
159	#[regex("@'(?:[^']|'')*'")]
160	StringSingleVerbatim,
161
162	#[regex(r"\|\|\|", lex_str_block_test)]
163	StringBlock, //(StringBlockToken),
164
165	#[regex("\"(?s:[^\"\\\\]|\\\\.)*")]
166	ErrorStringDoubleQuotedUnterminated,
167
168	#[regex("'(?s:[^'\\\\]|\\\\.)*")]
169	ErrorStringSingleQuotedUnterminated,
170
171	#[regex("@\"(?:[^\"]|\"\")*")]
172	ErrorStringDoubleVerbatimUnterminated,
173
174	#[regex("@'(?:[^']|'')*")]
175	ErrorStringSingleVerbatimUnterminated,
176
177	#[regex("@[^\"'\\s]\\S+")]
178	ErrorStringMissingQuotes,
179
180	#[token("/*/")]
181	ErrorCommentTooShort,
182
183	#[regex(r"/\*([^*]|\*[^/])+")]
184	ErrorCommentUnterminated,
185
186	#[regex(r"[ \t\n\r]+")]
187	Whitespace,
188
189	#[regex(r"//[^\r\n]*(\r\n|\n)?")]
190	SingelLineSlashComment,
191
192	#[regex(r"#[^\r\n]*(\r\n|\n)?")]
193	SingleLineHashComment,
194
195	#[regex(r"/\*([^*]|\*[^/])*\*/")]
196	MultiLineComment,
197
198	#[error]
199	Error,
200
201	ErrorPositionalAfterNamed,
202
203	Literal,
204	Expr,
205	Array,
206	ArrayElem,
207	Object,
208	Field,
209
210	CompspecFor,
211	CompspecIf,
212
213	Slice,
214	FieldAccess,
215	ObjectApply,
216	FunctionCall,
217	FunctionDef,
218	BodyDef,
219
220	BinOp,
221	UnaryOp,
222	Local,
223	ExprError,
224	ExprAssert,
225	ExprImport,
226
227	DefParam,
228	DefParams,
229
230	DefArgs,
231	DefNamedArg,
232	DefPositionalArg,
233
234	Parened,
235
236	Root,
237}
2388
239impl SyntaxKind {9impl SyntaxKind {
240	pub fn is_trivia(self) -> bool {10	pub fn is_trivia(self) -> bool {
241		matches!(11		matches!(
242			self,12			self,
243			Self::Whitespace13			Self::WHITESPACE
244				| Self::MultiLineComment14				| Self::MULTI_LINE_COMMENT
245				| Self::SingelLineSlashComment15				| Self::SINGLE_LINE_HASH_COMMENT
246				| Self::SingleLineHashComment16				| Self::SINGLE_LINE_SLASH_COMMENT
247		)17		)
248	}18	}
19	pub fn is_string(self) -> bool {
20		matches!(
21			self,
22			Self::STRING_SINGLE
23				| Self::STRING_DOUBLE
24				| Self::STRING_SINGLE_VERBATIM
25				| Self::STRING_DOUBLE_VERBATIM
26				| Self::STRING_BLOCK
27		)
28	}
29	pub fn is_number(self) -> bool {
30		matches!(self, Self::NUMBER)
31	}
32	pub fn is_literal(self) -> bool {
33		matches!(
34			self,
35			Self::NULL_KW
36				| Self::TRUE_KW | Self::FALSE_KW
37				| Self::SELF_KW | Self::DOLLAR
38				| Self::SUPER_KW
39		)
40	}
249}41}
25042
251pub struct Lexer<'a> {43pub struct Lexer<'a> {
293	Lexer::new(input).collect()85	Lexer::new(input).collect()
294}86}
295
296impl From<SyntaxKind> for rowan::SyntaxKind {
297	fn from(kind: SyntaxKind) -> Self {
298		Self(kind as u16)
299	}
300}
301
302use SyntaxKind::*;
303
304#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
305pub enum Lang {}
306impl rowan::Language for Lang {
307	type Kind = SyntaxKind;
308	fn kind_from_raw(raw: rowan::SyntaxKind) -> Self::Kind {
309		assert!(raw.0 <= Root as u16);
310		unsafe { std::mem::transmute::<u16, SyntaxKind>(raw.0) }
311	}
312	fn kind_to_raw(kind: Self::Kind) -> rowan::SyntaxKind {
313		kind.into()
314	}
315}
31687

1#![deny(unused_must_use)]1#![deny(unused_must_use)]
22
3mod ast;
3mod binary;4mod binary;
4mod event;5mod event;
6mod generated;
7mod language;
5mod lex;8mod lex;
6mod marker;9mod marker;
7mod parser;10mod parser;
8mod string_block;11mod string_block;
12mod tests;
9mod token_set;13mod token_set;
10mod unary;14mod unary;
1115
12#[cfg(test)]
13mod tests {
14	use miette::{Diagnostic, GraphicalReportHandler, LabeledSpan};16pub use generated::syntax_kinds::SyntaxKind;
15	use thiserror::Error;
16
17	use crate::parser::parse;
18
19	#[derive(Debug, Error)]
20	#[error("syntax error")]
21	struct MyDiagnostic {
22		code: String,
23		spans: Vec<LabeledSpan>,
24	}
25	impl Diagnostic for MyDiagnostic {
26		fn code<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
27			None
28		}
29
30		fn severity(&self) -> Option<miette::Severity> {
31			None
32		}
33
34		fn help<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
35			None
36		}
37
38		fn url<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
39			None
40		}
41
42		fn source_code(&self) -> Option<&dyn miette::SourceCode> {
43			Some(&self.code)
44		}
45
46		fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
47			Some(Box::new(self.spans.clone().into_iter()))
48		}
49
50		fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>> {
51			None
52		}
53	}
54
55	fn process(text: &str) -> String {
56		use std::fmt::Write;17pub use language::{
57		let mut out = String::new();
58		let node = parse(text);
59		write!(out, "{:#?}", node.syntax()).unwrap();
60		if !node.errors.is_empty() && !text.is_empty() {
61			writeln!(out, "===").unwrap();18	JsonnetLanguage, PreorderWithTokens, SyntaxElement, SyntaxElementChildren, SyntaxNode,
62			for err in &node.errors {
63				writeln!(out, "{:?}", err).unwrap();
64			}
65			let diag = MyDiagnostic {
66				code: text.to_string(),
67				spans: node.errors.into_iter().map(|e| e.into()).collect(),
68			};
69
70			let handler = GraphicalReportHandler::new();
71
72			write!(out, "===").unwrap();19	SyntaxNodeChildren, SyntaxToken,
73			handler.render_report(&mut out, &diag).unwrap();
74		}20};
75		out
76	}
77	macro_rules! mk_test {
78		($($name:ident => $test:expr)+) => {$(
79			#[test]
80			fn $name() {
81				let src = indoc::indoc!($test);
82				let result = process(&src);
83				insta::assert_snapshot!(stringify!($name), result, src);
84
85			}
86		)+};
87	}
88	mk_test!(
89		empty => r#" "#
90		function => r#"
91			function(a, b = 1) a + b
92		"#
93		function_error_no_value => r#"
94			function(a, b = ) a + b
95		"#
96		function_error_rparen => r#"
97			function(a, b
98		"#
99		function_error_body => r#"
100			function(a, b)
101		"#
102		local_novalue => r#"
103			local a =
104		"#
105		local_no_value_recovery => r#"
106			local a =
107			local b = 3;
108			1
109		"#
110
111		array_comp => r#"
112			[a for a in [1, 2, 3]]
113		"#
114		array_comp_incompatible_with_multiple_elems => r#"
115			[a for a in [1, 2, 3], b]
116		"#
117
118		no_rhs => r#"
119			a +
120		"#
121		no_lhs => r#"
122			+ 2
123		"#
124		no_operator => "
125			2 2
126		"
127
128		named_before_positional => "
129			a(1, 2, b=4, 3, 5, k = 12, 6)
130		"
131
132		wrong_field_end => "
133			{
134				a: 1;
135				b: 2;
136			}
137		"
138	);
139}
14021

1use drop_bomb::DropBomb;1use drop_bomb::DropBomb;
2use rowan::TextRange;2use rowan::TextRange;
33
4use crate::{event::Event, lex::SyntaxKind, parser::Parser};4use crate::{event::Event, parser::Parser, SyntaxKind};
55
6pub struct Ranger {6pub struct Ranger {
7	pub pos: usize,7	pub pos: usize,

1use std::cell::Cell;1use std::{cell::Cell, fmt::Display, rc::Rc};
2use std::fmt::Display;
3use std::rc::Rc;
42
5use miette::Diagnostic;3use miette::{LabeledSpan, SourceOffset, SourceSpan};
6use miette::LabeledSpan;
7use miette::SourceOffset;
8use miette::SourceSpan;
9use rowan::GreenNode;4use rowan::{GreenNode, TextRange, TextSize};
105
11use rowan::TextRange;6use crate::{
7	binary::BinaryOperator,
12use rowan::TextSize;8	event::{Event, Sink},
9	lex::{lex, Lexeme},
13use thiserror::Error;10	marker::{AsRange, CompletedMarker, Marker, Ranger},
11	token_set::SyntaxKindSet,
12	unary::UnaryOperator,
13	SyntaxKind,
14	SyntaxKind::*,
15	SyntaxNode, T, TS,
16};
1417
15use crate::binary::BinaryOperator;
16use crate::event::Event;
17use crate::event::Sink;
18use crate::lex::lex;
19use crate::lex::Lang;
20use crate::lex::Lexeme;
21use crate::lex::SyntaxKind;
22use crate::lex::SyntaxKind::*;
23use crate::marker::AsRange;
24use crate::marker::CompletedMarker;
25use crate::marker::FinishedRanger;
26use crate::marker::Marker;
27use crate::marker::Ranger;
28use crate::token_set::TokenSet;
29use crate::unary::UnaryOperator;
30
31pub struct Parse {18pub struct Parse {
32	pub green_node: GreenNode,19	pub green_node: GreenNode,
33	pub errors: Vec<SyntaxError>,20	pub errors: Vec<SyntaxError>,
58	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,45	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,
59}46}
6047
61const DEFAULT_RECOVERY_SET: TokenSet = TokenSet::new(&[48const DEFAULT_RECOVERY_SET: SyntaxKindSet = TS![; ')' ']' '}' local];
62	SymbolSemi,
63	RParen,
64	SymbolRightBracket,
65	SymbolRightBrace,
66	KeywordLocal,
67]);
6849
69#[derive(Clone, Debug, PartialEq, Eq)]50#[derive(Clone, Debug, PartialEq, Eq)]
70pub enum SyntaxError {51pub enum SyntaxError {
172			let end = ranger.finish(&self);153			let end = ranger.finish(&self);
173			self.custom_error(end, "unexpected input after expression");154			self.custom_error(end, "unexpected input after expression");
174		}155		}
175		m.complete(&mut self, Root);156		m.complete(&mut self, SOURCE_FILE);
176157
177		self.events158		self.events
178	}159	}
179160
180	pub(crate) fn expect(&mut self, kind: SyntaxKind) {161	pub(crate) fn expect(&mut self, kind: SyntaxKind) {
181		self.expect_with_recovery_set(kind, TokenSet::default())162		self.expect_with_recovery_set(kind, TS![])
182	}163	}
183164
184	pub(crate) fn expect_with_recovery_set(&mut self, kind: SyntaxKind, recovery_set: TokenSet) {165	pub(crate) fn expect_with_recovery_set(
166		&mut self,
167		kind: SyntaxKind,
168		recovery_set: SyntaxKindSet,
169	) {
185		if self.at(kind) {170		if self.at(kind) {
186			self.bump();171			self.bump();
187		} else {172		} else {
239	}224	}
240	pub(crate) fn error_with_recovery_set(225	pub(crate) fn error_with_recovery_set(
241		&mut self,226		&mut self,
242		recovery_set: TokenSet,227		recovery_set: SyntaxKindSet,
243	) -> Option<CompletedMarker> {228	) -> Option<CompletedMarker> {
244		self.error_with_recovery_set_no_default(recovery_set.union(DEFAULT_RECOVERY_SET))229		self.error_with_recovery_set_no_default(recovery_set.union(DEFAULT_RECOVERY_SET))
245	}230	}
246	pub fn error_with_no_skip(&mut self) -> Option<CompletedMarker> {231	pub fn error_with_no_skip(&mut self) -> Option<CompletedMarker> {
247		self.error_with_recovery_set_no_default(TokenSet::ALL)232		self.error_with_recovery_set_no_default(SyntaxKindSet::ALL)
248	}233	}
249234
250	pub fn error_with_recovery_set_no_default(235	pub fn error_with_recovery_set_no_default(
251		&mut self,236		&mut self,
252		recovery_set: TokenSet,237		recovery_set: SyntaxKindSet,
253	) -> Option<CompletedMarker> {238	) -> Option<CompletedMarker> {
254		let expected_syntax = self.expected_syntax.take().unwrap();239		let expected_syntax = self.expected_syntax.take().unwrap();
255		self.expected_syntax_tracking_state240		self.expected_syntax_tracking_state
280265
281		let m = self.start();266		let m = self.start();
282		self.bump();267		self.bump();
283		Some(m.complete(self, SyntaxKind::Error))268		Some(m.complete(self, SyntaxKind::ERROR))
284	}269	}
285270
286	fn bump(&mut self) {271	fn bump(&mut self) {
323		}308		}
324		self.peek() == Some(kind)309		self.peek() == Some(kind)
325	}310	}
326	pub fn at_set(&mut self, set: TokenSet) -> bool {311	pub fn at_set(&mut self, set: SyntaxKindSet) -> bool {
327		self.peek().map_or(false, |k| set.contains(k))312		self.peek().map_or(false, |k| set.contains(k))
328	}313	}
329	pub fn at_end(&mut self) -> bool {314	pub fn at_end(&mut self) -> bool {
356}341}
357macro_rules! at_match {342macro_rules! at_match {
358	($p:ident {343	($p:ident {
359		$($r:ident => $e:expr,)*344		$($r:expr => $e:expr,)*
360		_ => $else:expr $(,)?345		_ => $else:expr $(,)?
361	}) => {{346	}) => {{
362		$(347		$(
375360
376	loop {361	loop {
377		let op = at_match!(p {362		let op = at_match!(p {
378			OpMul => BinaryOperator::Mul,363			T![*] => BinaryOperator::Mul,
379			OpDiv => BinaryOperator::Div,364			T![/] => BinaryOperator::Div,
380			OpMod => BinaryOperator::Mod,365			T![%] => BinaryOperator::Mod,
381			OpPlus => BinaryOperator::Plus,366			T![+] => BinaryOperator::Plus,
382			OpMinus => BinaryOperator::Minus,367			T![-] => BinaryOperator::Minus,
383			OpShiftLeft => BinaryOperator::ShiftLeft,368			T![<<] => BinaryOperator::ShiftLeft,
384			OpShiftRight => BinaryOperator::ShiftRight,369			T![>>] => BinaryOperator::ShiftRight,
385			OpLessThan => BinaryOperator::LessThan,370			T![<] => BinaryOperator::LessThan,
386			OpGreaterThan => BinaryOperator::GreaterThan,371			T![>] => BinaryOperator::GreaterThan,
387			OpLessThanOrEqual => BinaryOperator::LessThanOrEqual,372			T![<=] => BinaryOperator::LessThanOrEqual,
388			OpGreaterThanOrEqual => BinaryOperator::GreaterThanOrEqual,373			T![>=] => BinaryOperator::GreaterThanOrEqual,
389			OpEqual => BinaryOperator::Equal,374			T![==] => BinaryOperator::Equal,
390			OpNotEqual => BinaryOperator::NotEqual,375			T![!=] => BinaryOperator::NotEqual,
391			OpBitAnd => BinaryOperator::BitAnd,376			T![&] => BinaryOperator::BitAnd,
392			OpBitXor => BinaryOperator::BitXor,377			T![^] => BinaryOperator::BitXor,
393			OpBitOr => BinaryOperator::BitOr,378			T![|] => BinaryOperator::BitOr,
394			OpAnd => BinaryOperator::And,379			T![&&] => BinaryOperator::And,
395			OpOr => BinaryOperator::Or,380			T![||] => BinaryOperator::Or,
396			OpIn => BinaryOperator::In,381			T![in] => BinaryOperator::In,
397			SymbolLeftBrace => BinaryOperator::ObjectApply,382			T!['{'] => BinaryOperator::ObjectApply,
398			_ => break,383			_ => break,
399		});384		});
400		let (left_binding_power, right_binding_power) = op.binding_power();385		let (left_binding_power, right_binding_power) = op.binding_power();
412		lhs = m.complete(397		lhs = m.complete(
413			p,398			p,
414			if op == BinaryOperator::ObjectApply {399			if op == BinaryOperator::ObjectApply {
415				ObjectApply400				EXPR_OBJ_EXTEND
416			} else {401			} else {
417				BinOp402				EXPR_BINARY
418			},403			},
419		);404		);
420405
425	Some(lhs)410	Some(lhs)
426}411}
427fn compspec(p: &mut Parser) {412fn compspec(p: &mut Parser) {
428	assert!(p.at(KeywordFor) || p.at(KeywordIf));413	assert!(p.at(T![for]) || p.at(T![if]));
429	if p.at(KeywordFor) {414	if p.at(T![for]) {
430		let m = p.start();415		let m = p.start();
431		p.bump();416		p.bump();
432		p.expect(Ident);417		p.expect(IDENT);
433		p.expect(OpIn);418		p.expect(T![in]);
434		expr(p);419		expr(p);
435		m.complete(p, CompspecFor);420		m.complete(p, FOR_SPEC);
436	} else if p.at(KeywordIf) {421	} else if p.at(T![in]) {
437		let m = p.start();422		let m = p.start();
438		p.bump();423		p.bump();
439		expr(p);424		expr(p);
440		m.complete(p, CompspecIf);425		m.complete(p, IF_SPEC);
441	} else {426	} else {
442		unreachable!()427		unreachable!()
443	}428	}
444}429}
445fn comma(p: &mut Parser) -> bool {430fn comma(p: &mut Parser) -> bool {
446	if p.at(SymbolComma) {431	if p.at(T![,]) {
447		p.bump();432		p.bump();
448		true433		true
449	} else {434	} else {
450		false435		false
451	}436	}
452}437}
453fn comma_with_alternatives(p: &mut Parser, set: TokenSet) -> bool {438fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {
454	if p.at(SymbolComma) {439	if p.at(T![,]) {
455		p.bump();440		p.bump();
456		true441		true
457	} else if p.at_set(set) {442	} else if p.at_set(set) {
458		p.expect_with_no_skip(SymbolComma);443		p.expect_with_no_skip(T![,]);
459		p.bump();444		p.bump();
460		true445		true
461	} else {446	} else {
464}449}
465fn field_name(p: &mut Parser) {450fn field_name(p: &mut Parser) {
466	let _e = p.expected_syntax_name("field name");451	let _e = p.expected_syntax_name("field name");
467	if p.at(SymbolLeftBracket) {452	if p.at(T!['[']) {
468		p.bump();453		p.bump();
469		expr(p);454		expr(p);
470		p.expect(SymbolRightBracket);455		p.expect(T![']']);
471	} else if p.at(Ident) {456	} else if p.at(IDENT) {
472		p.bump()457		p.bump()
473	} else {458	} else {
474		p.error_with_recovery_set(TokenSet::new(&[SymbolSemi]));459		p.error_with_recovery_set(TS![;]);
475	}460	}
476}461}
477fn object(p: &mut Parser) -> CompletedMarker {462fn object(p: &mut Parser) -> CompletedMarker {
478	assert!(p.at(SymbolLeftBrace));463	assert!(p.at(T!['{']));
479	let m = p.start();464	let m = p.start();
480	p.bump();465	p.bump();
481466
482	loop {467	loop {
483		if p.at(SymbolRightBrace) {468		if p.at(T!['}']) {
484			p.bump();469			p.bump();
485			break;470			break;
486		}471		}
487		let m = p.start();472		let m = p.start();
488		field_name(p);473		field_name(p);
489		p.expect(SymbolColon);474		p.expect(T![,]);
490		expr(p);475		expr(p);
491		while p.at(KeywordFor) || p.at(KeywordIf) {476		while p.at(T![for]) || p.at(T![if]) {
492			compspec(p)477			compspec(p)
493		}478		}
494		m.complete(p, Field);479		m.complete(p, MEMBER);
495		if comma_with_alternatives(p, TokenSet::new(&[SymbolAssign])) {480		if comma_with_alternatives(p, SyntaxKindSet::new(&[T![=]])) {
496			continue;481			continue;
497		}482		}
498		p.expect(SymbolRightBrace);483		p.expect(R_BRACE);
499		break;484		break;
500	}485	}
501486
502	m.complete(p, Object)487	m.complete(p, OBJ_BODY)
503}488}
504489
505fn params(p: &mut Parser) -> CompletedMarker {490fn params(p: &mut Parser) -> CompletedMarker {
506	assert!(p.at(LParen));491	assert!(p.at(T!['(']));
507	let m = p.start();492	let m = p.start();
508	p.bump();493	p.bump();
509494
510	loop {495	loop {
511		if p.at(RParen) {496		if p.at(T![')']) {
512			p.bump();497			p.bump();
513			break;498			break;
514		}499		}
515		let m = p.start();500		let m = p.start();
516		p.expect(Ident);501		p.expect(IDENT);
517		if p.at(SymbolAssign) {502		if p.at(T![=]) {
518			p.bump();503			p.bump();
519			expr(p);504			expr(p);
520		}505		}
521		m.complete(p, DefParam);506		m.complete(p, PARAM);
522		if comma(p) {507		if comma(p) {
523			continue;508			continue;
524		}509		}
525		p.expect(RParen);510		p.expect(T![')']);
526		break;511		break;
527	}512	}
528513
529	m.complete(p, DefParams)514	m.complete(p, PARAMS_DESC)
530}515}
531fn args(p: &mut Parser) {516fn args(p: &mut Parser) {
532	assert!(p.at(LParen));517	assert!(p.at(T!['(']));
533	p.bump();518	p.bump();
534519
535	let mut error_positional_start = None::<Marker>;520	let mut error_positional_start = None::<Marker>;
536	let mut started_named = Cell::new(false);521	let mut started_named = Cell::new(false);
537	let mut on_positional = |p: &mut Parser, m: Marker| {522	let mut on_positional = |p: &mut Parser, m: Marker| {
538		let c = m.complete(p, DefPositionalArg);523		let c = m.complete(p, ARG);
539		if started_named.get() && error_positional_start.is_none() {524		if started_named.get() && error_positional_start.is_none() {
540			error_positional_start = Some(c.precede(p));525			error_positional_start = Some(c.precede(p));
541		}526		}
542	};527	};
543	loop {528	loop {
544		if p.at(RParen) {529		if p.at(T![')']) {
545			break;530			break;
546		}531		}
547532
548		let m = p.start();533		let m = p.start();
549		if p.at(Ident) {534		if p.at(IDENT) {
550			p.bump();535			p.bump();
551			if p.at(SymbolAssign) {536			if p.at(T![=]) {
552				p.bump();537				p.bump();
553				expr(p);538				expr(p);
554				m.complete(p, DefNamedArg);539				m.complete(p, ARG);
555				started_named.set(true);540				started_named.set(true);
556			} else {541			} else {
557				on_positional(p, m);542				on_positional(p, m);
566		break;551		break;
567	}552	}
568	if let Some(error_positional_start) = error_positional_start {553	if let Some(error_positional_start) = error_positional_start {
569		let c = error_positional_start.complete(p, ErrorPositionalAfterNamed);554		let c = error_positional_start.complete(p, ERROR);
570		p.custom_error(c, "positional arguments can't be placed after named")555		p.custom_error(c, "positional arguments can't be placed after named")
571	}556	}
572	p.expect(RParen);557	p.expect(T![')']);
573}558}
574559
575fn array(p: &mut Parser) -> CompletedMarker {560fn array(p: &mut Parser) -> CompletedMarker {
576	assert!(p.at(SymbolLeftBracket));561	assert!(p.at(T!['[']));
577	// Start the list node562	// Start the list node
578	let m = p.start();563	let m = p.start();
579	p.bump(); // '['564	p.bump(); // '['
583	let mut elems = 0;568	let mut elems = 0;
584569
585	loop {570	loop {
586		if p.at(SymbolRightBracket) {571		if p.at(T![']']) {
587			p.bump();572			p.bump();
588			break;573			break;
589		}574		}
590		elems += 1;575		elems += 1;
591		let m = p.start();576		expr(p);
592		{
593			let m = p.start();
594			expr(p);
595			m.complete(p, BodyDef);
596		}
597		let c = p.start_ranger();577		let c = p.start_ranger();
598		let mut had_spec = false;578		let mut had_spec = false;
599		while p.at(KeywordFor) || p.at(KeywordIf) {579		while p.at(T![for]) || p.at(T![if]) {
600			had_spec = true;580			had_spec = true;
601			compspec(p)581			compspec(p)
602		}582		}
603		if had_spec {583		if had_spec {
604			compspecs.push(c.finish(p));584			compspecs.push(c.finish(p));
605		}585		}
606		m.complete(p, ArrayElem);
607		if comma(p) {586		if comma(p) {
608			continue;587			continue;
609		}588		}
610		p.expect(SymbolRightBracket);589		p.expect(T![']']);
611		break;590		break;
612	}591	}
613592
618				"compspec may only be used if there is only one array element",597				"compspec may only be used if there is only one array element",
619			)598			)
620		}599		}
600
601		m.complete(p, EXPR_ARRAY)
602	} else if !compspecs.is_empty() {
603		m.complete(p, EXPR_ARRAY_COMP)
604	} else {
605		m.complete(p, EXPR_ARRAY)
621	}606	}
622
623	m.complete(p, Array)
624}607}
625608
626fn lhs(p: &mut Parser) -> Option<CompletedMarker> {609fn lhs(p: &mut Parser) -> Option<CompletedMarker> {
627	let mut lhs = lhs_basic(p)?;610	let mut lhs = lhs_basic(p)?;
628611
629	loop {612	loop {
630		if p.at(SymbolDot) {613		if p.at(T![.]) {
631			let m = lhs.precede(p);614			let m = lhs.precede(p);
632			p.bump();615			p.bump();
633			p.expect(Ident);616			p.expect(IDENT);
634			lhs = m.complete(p, FieldAccess);617			lhs = m.complete(p, EXPR_INDEX);
635		} else if p.at(SymbolLeftBracket) {618		} else if p.at(T!['[']) {
636			let m = lhs.precede(p);619			let m = lhs.precede(p);
637			p.bump();620			p.bump();
638			// Start621			// Start
639			if !p.at(SymbolColon) {622			if !p.at(T![:]) {
640				expr(p);623				expr(p);
641			}624			}
642			if p.at(SymbolColon) {625			if p.at(T![:]) {
643				p.bump();626				p.bump();
644				// End627				// End
645				if !p.at(SymbolRightBracket) && !p.at(SymbolColon) {628				if !p.at(T![']']) && !p.at(T![:]) {
646					expr(p);629					expr(p);
647				}630				}
648				if p.at(SymbolColon) {631				if p.at(T![:]) {
649					p.bump();632					p.bump();
650					// Step633					// Step
651					if !p.at(SymbolRightBracket) {634					if !p.at(T![']']) {
652						expr(p);635						expr(p);
653					}636					}
654				}637				}
655			}638			}
656			p.expect(SymbolRightBracket);639			p.expect(T![']']);
657			lhs = m.complete(p, Slice);640			lhs = m.complete(p, EXPR_SLICE);
658		} else if p.at(LParen) {641		} else if p.at(T!['(']) {
659			let m = lhs.precede(p);642			let m = lhs.precede(p);
660			args(p);643			args(p);
661			lhs = m.complete(p, FunctionCall);644			lhs = m.complete(p, EXPR_APPLY);
662		} else {645		} else {
663			break;646			break;
664		}647		}
669652
670fn lhs_basic(p: &mut Parser) -> Option<CompletedMarker> {653fn lhs_basic(p: &mut Parser) -> Option<CompletedMarker> {
671	let _e = p.expected_syntax_name("value");654	let _e = p.expected_syntax_name("value");
672	Some(655	Some(if p.peek().map(|l| l.is_literal()).unwrap_or(false) {
673		if p.at(Number)
674			|| p.at(StringSingleQuoted)
675			|| p.at(StringDoubleQuoted)656		let m = p.start();
676			|| p.at(StringSingleVerbatim)657		p.bump();
677			|| p.at(StringDoubleVerbatim)658		m.complete(p, EXPR_LITERAL)
678			|| p.at(StringBlock)659	} else if p.peek().map(|l| l.is_string()).unwrap_or(false) {
679			|| p.at(KeywordNull)660		let m = p.start();
680			|| p.at(SymbolDollar)661		p.bump();
681			|| p.at(KeywordSuper)662		m.complete(p, EXPR_STRING)
682			|| p.at(KeywordSelf)663	} else if p.peek().map(|l| l.is_number()).unwrap_or(false) {
683		{
684			let m = p.start();664		let m = p.start();
685			p.bump();665		p.bump();
686			m.complete(p, Literal)666		m.complete(p, EXPR_NUMBER)
687		} else if p.at(Ident) {667	} else if p.at(IDENT) {
688			let m = p.start();668		let m = p.start();
689			p.bump();669		p.bump();
690			m.complete(p, Ident)670		m.complete(p, EXPR_VAR)
691		} else if p.at(SymbolLeftBracket) {671	} else if p.at(T!['[']) {
692			array(p)672		array(p)
693		} else if p.at(SymbolLeftBrace) {673	} else if p.at(T!['{']) {
694			object(p)674		object(p)
695		} else if p.at(KeywordLocal) {675	} else if p.at(T![local]) {
696			let m = p.start();676		let m = p.start();
697			p.bump();677		p.bump();
698			let mut sus_local = None;678		let mut sus_local = None;
699			loop {679		loop {
700				p.expect_with_recovery_set(680			p.expect_with_recovery_set(IDENT, TS![= ; local]);
701					Ident,
702					TokenSet::new(&[SymbolAssign, SymbolSemi, KeywordLocal]),
703				);
704				if p.at(LParen) {681			if p.at(T!['(']) {
705					params(p);682				params(p);
706				}683			}
707684
708				let sus_local_candidate = p.start_ranger();685			let sus_local_candidate = p.start_ranger();
709				p.expect_with_recovery_set(686			p.expect_with_recovery_set(T![=], TS![; local]);
710					SymbolAssign,
711					TokenSet::new(&[SymbolSemi, KeywordLocal]),
712				);
713687
714				sus_local = p.at(KeywordLocal).then(|| sus_local_candidate.finish(p));688			sus_local = p.at(T![local]).then(|| sus_local_candidate.finish(p));
715				expr(p);689			expr(p);
716690
717				if !comma(p) {691			if !comma(p) {
718					break;692				break;
719				}
720			}693			}
721			p.expect(SymbolSemi);694		}
695		p.expect(T![;]);
722			if let Some(sus_local) = sus_local {696		if let Some(sus_local) = sus_local {
723				if sus_local.had_error_since(p) {697			if sus_local.had_error_since(p) {
724					p.custom_error(sus_local, "unusal local placement, missing ';' ?")698				p.custom_error(sus_local, "unusal local placement, missing ';' ?")
725				}
726			}699			}
727			{700		}
701		expr(p);
728				let m = p.start();702		m.complete(p, T![local])
703	} else if p.at(T![function]) {
704		let m = p.start();
729				expr(p);705		p.bump();
706		args(p);
730				m.complete(p, BodyDef);707		expr(p);
708		m.complete(p, EXPR_FUNCTION)
709	} else if p.at(T![error]) {
710		let m = p.start();
731			}711		p.bump();
712		expr(p);
732			m.complete(p, Local)713		m.complete(p, EXPR_ERROR)
733		} else if p.at(KeywordFunction) {714	} else if p.at(T![assert]) {
734			let m = p.start();715		let m = p.start();
716		p.bump();
717		expr(p);
718		if p.at(T![:]) {
735			p.bump();719			p.bump();
736			args(p);
737			{
738				let m = p.start();
739				expr(p);
740				m.complete(p, BodyDef);
741			}
742			m.complete(p, FunctionDef)
743		} else if p.at(KeywordError) {
744			let m = p.start();
745			p.bump();
746			expr(p);720			expr(p);
747			m.complete(p, ExprError)721		}
722		m.complete(p, EXPR_ASSERT)
748		} else if p.at(KeywordAssert) {723	} else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {
749			let m = p.start();
750			p.bump();
751			expr(p);
752			if p.at(SymbolColon) {
753				p.bump();
754				expr(p);
755			}
756			m.complete(p, ExprAssert)
757		} else if p.at(KeywordImport) || p.at(KeywordImportStr) {
758			let m = p.start();724		let m = p.start();
759			p.bump();725		p.bump();
760			expr(p);726		expr(p);
761			m.complete(p, ExprImport)727		m.complete(p, EXPR_IMPORT)
762		} else if p.at(OpMinus) || p.at(OpNot) || p.at(OpBitNegate) {728	} else if p.at(T![-]) || p.at(T![!]) || p.at(T![~]) {
763			let op = match p.peek().unwrap() {729		let op = match p.peek().unwrap() {
764				OpMinus => UnaryOperator::Minus,730			T![-] => UnaryOperator::Minus,
765				OpNot => UnaryOperator::Not,731			T![!] => UnaryOperator::Not,
766				OpBitNegate => UnaryOperator::BitNegate,732			T![~] => UnaryOperator::BitNegate,
767				_ => unreachable!(),733			_ => unreachable!(),
768			};734		};
769			let ((), right_binding_power) = op.binding_power();735		let ((), right_binding_power) = op.binding_power();
770736
771			let m = p.start();737		let m = p.start();
772			p.bump();738		p.bump();
773			expr_binding_power(p, right_binding_power);739		expr_binding_power(p, right_binding_power);
774			m.complete(p, UnaryOp)740		m.complete(p, EXPR_UNARY)
775		} else if p.at(LParen) {741	} else if p.at(T!['(']) {
776			let m = p.start();742		let m = p.start();
777			p.bump();743		p.bump();
778			expr(p);744		expr(p);
779			assert!(p.at(RParen));745		assert!(p.at(T![')']));
780			p.bump();746		p.bump();
781			m.complete(p, Parened)747		m.complete(p, EXPR_PARENED)
782		} else {748	} else {
783			p.error_with_no_skip();749		p.error_with_no_skip();
784			return None;750		return None;
785		},751	})
786	)
787}752}
788
789type SyntaxNode = rowan::SyntaxNode<Lang>;
790#[allow(unused)]
791type SyntaxToken = rowan::SyntaxToken<Lang>;
792#[allow(unused)]
793type SyntaxElement = rowan::NodeOrToken<SyntaxNode, SyntaxToken>;
794753
795impl Parse {754impl Parse {
796	pub fn syntax(&self) -> SyntaxNode {755	pub fn syntax(&self) -> SyntaxNode {