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

194194
195MemberBindStmt = ObjLocal195MemberBindStmt = ObjLocal
196MemberAssertStmt = Assertion196MemberAssertStmt = Assertion
197MemberField = Field197MemberFieldNormal =
198Member =
199    MemberBindStmt
200|   MemberAssertStmt
201|   MemberField
202
203ObjLocal =
204    'local'
205    Bind
206
207FieldNormal =
208    FieldName198    FieldName
209    '+'?199    '+'?
210    Visibility200    Visibility
211    Expr201    Expr
212FieldMethod =202MemberFieldMethod =
213    FieldName203    FieldName
214    ParamsDesc204    ParamsDesc
215    Visibility205    Visibility
216    Expr206    Expr
217Field =207Member =
218    FieldNormal208    MemberBindStmt
219|   FieldMethod209|   MemberAssertStmt
210|   MemberFieldNormal
211|   MemberFieldMethod
212
213ObjLocal =
214    'local'
215    Bind
220216
221FieldNameFixed =217FieldNameFixed =
222    id:Name218    id:Name
374ParsingError =370ParsingError =
375    'ERROR_MISSING_TOKEN!'371    'ERROR_MISSING_TOKEN!'
376|   'ERROR_UNEXPECTED_TOKEN!'372|   'ERROR_UNEXPECTED_TOKEN!'
373|   'ERROR_CUSTOM!'
377374

1use std::mem;1use std::{mem, num::NonZeroUsize};
22
3use rowan::{GreenNodeBuilder, Language, TextRange, TextSize};3use rowan::{GreenNodeBuilder, Language, TextRange, TextSize};
44
9	AstToken, JsonnetLanguage, SyntaxKind,9	AstToken, JsonnetLanguage, SyntaxKind,
10};10};
1111
12#[derive(Clone, Debug, PartialEq, Eq)]12#[derive(Clone, Debug)]
13pub enum Event {13pub enum Event {
14	/// Used for unfinished markers14	/// Used for unfinished markers
15	Pending,15	Pending,
18		kind: SyntaxKind,18		kind: SyntaxKind,
19		/// If marker is preceded or wrapped - instead of reordering events, we19		/// If marker is preceded or wrapped - instead of reordering events, we
20		/// insert start event in the end of events Vec instead, and store relative offset to this event here20		/// insert start event in the end of events Vec instead, and store relative offset to this event here
21		forward_parent: Option<usize>,21		forward_parent: Option<NonZeroUsize>,
22	},22	},
23	/// Eat token23	/// Eat token
24	Token {24	Token { kind: SyntaxKind },
31	/// Position of finished node27	/// Position of finished node
32	Finish {28	Finish {
33		/// Same as forward_parent of Start, but for wrapping29		/// Same as forward_parent of Start, but for wrapping
34		wrapper: Option<usize>,30		wrapper: Option<NonZeroUsize>,
31		error: Option<Box<SyntaxError>>,
35	},32	},
36	Error(SyntaxError),
37	/// Used for dropped markers and other things33	/// Used for dropped markers and other things
38	Noop,34	Noop,
39}35}
74		let mut eat_start_whitespace = false;70		let mut eat_start_whitespace = false;
75		let mut depth = 0;71		let mut depth = 0;
76		let mut error_starts_at = Vec::new();72		let mut error_starts_at = Vec::new();
77		let mut error_last_range = None;
78		for idx in 0..self.events.len() {73		for idx in 0..self.events.len() {
79			match mem::replace(&mut self.events[idx], Event::Noop) {74			match mem::replace(&mut self.events[idx], Event::Noop) {
80				Event::Start {75				Event::Start {
84					if depth != 0 {79					if depth != 0 {
85						self.skip_whitespace();80						self.skip_whitespace();
86					}81					}
87					error_last_range = None;
88					let mut kinds = vec![kind];82					let mut kinds = vec![kind];
8983
90					let mut idx = idx;84					let mut idx = idx;
94					// of that, and of that, etc. until we reach a StartNode event without a forward88					// of that, and of that, etc. until we reach a StartNode event without a forward
95					// parent.89					// parent.
96					while let Some(fp) = forward_parent {90					while let Some(fp) = forward_parent {
97						idx += fp;91						idx += fp.get();
9892
99						forward_parent = if let Event::Start {93						forward_parent = if let Event::Start {
100							kind,94							kind,
123					if eat_start_whitespace {117					if eat_start_whitespace {
124						self.skip_whitespace();118						self.skip_whitespace();
125					}119					}
126					error_last_range = None;
127					self.token(kind);120					self.token(kind);
128					eat_start_whitespace = true;121					eat_start_whitespace = true;
129				}122				}
130				Event::VirtualToken { kind } => {123				Event::VirtualToken { kind } => {
131					if eat_start_whitespace {124					if eat_start_whitespace {
132						self.skip_whitespace();125						self.skip_whitespace();
133					}126					}
134					error_last_range = None;
135					self.virtual_token(kind);127					self.virtual_token(kind);
136					eat_start_whitespace = false;128					eat_start_whitespace = false;
137				}129				}
138				Event::Finish { wrapper } => {130				Event::Finish { wrapper, error } => {
139					if depth == 1 {131					if depth == 1 {
140						self.skip_whitespace();132						self.skip_whitespace();
141					}133					}
142					error_last_range = Some((134					let range = (
143						error_starts_at.pop().expect("starts == finishes"),135						error_starts_at.pop().expect("starts == finishes"),
144						self.text_offset(),136						self.text_offset(),
145					));137					);
138					if let Some(error) = error {
139						self.errors.push(LocatedSyntaxError {
140							error: *error,
141							range: TextRange::new(range.0, range.1),
142						})
143					}
146					self.builder.finish_node();144					self.builder.finish_node();
147					depth -= 1;145					depth -= 1;
148					let mut idx = idx;146					let mut idx = idx;
149					let mut wrapper = wrapper;147					let mut wrapper = wrapper;
150					while let Some(w) = wrapper {148					while let Some(w) = wrapper {
151						idx += w;149						idx += w.get();
152						wrapper = if let Event::Finish { wrapper } =150						wrapper = if let Event::Finish { wrapper, error } =
153							mem::replace(&mut self.events[idx], Event::Noop)151							mem::replace(&mut self.events[idx], Event::Noop)
154						{152						{
155							error_last_range = Some((153							let range = (
156								error_starts_at.pop().expect("starts == finishes"),154								error_starts_at.pop().expect("starts == finishes"),
157								self.text_offset(),155								self.text_offset(),
158							));156							);
157							if let Some(error) = error {
158								self.errors.push(LocatedSyntaxError {
159									error: *error,
160									range: TextRange::new(range.0, range.1),
161								})
162							}
163
159							if depth == 1 {164							if depth == 1 {
160								self.skip_whitespace();165								self.skip_whitespace();
170				}175				}
171				Event::Pending => panic!("pending event should not appear in finished events"),176				Event::Pending => panic!("pending event should not appear in finished events"),
172				Event::Noop => {}177				Event::Noop => {}
173				Event::Error(error) => {
174					let (start, end) = error_last_range
175						.take()
176						.expect("expected error event right after closed node");
177					self.errors.push(LocatedSyntaxError {
178						error,
179						range: TextRange::new(start, end),
180					});
181				}
182			}178			}
183		}179		}
184180

643}643}
644644
645#[derive(Debug, Clone, PartialEq, Eq, Hash)]645#[derive(Debug, Clone, PartialEq, Eq, Hash)]
646pub struct MemberField {646pub struct MemberFieldNormal {
647	pub(crate) syntax: SyntaxNode,647	pub(crate) syntax: SyntaxNode,
648}648}
649impl MemberField {
650	pub fn field(&self) -> Option<Field> {
651		support::child(&self.syntax)
652	}
653}
654
655#[derive(Debug, Clone, PartialEq, Eq, Hash)]
656pub struct FieldNormal {
657	pub(crate) syntax: SyntaxNode,
658}
659impl FieldNormal {649impl MemberFieldNormal {
660	pub fn field_name(&self) -> Option<FieldName> {650	pub fn field_name(&self) -> Option<FieldName> {
661		support::child(&self.syntax)651		support::child(&self.syntax)
662	}652	}
672}662}
673663
674#[derive(Debug, Clone, PartialEq, Eq, Hash)]664#[derive(Debug, Clone, PartialEq, Eq, Hash)]
675pub struct FieldMethod {665pub struct MemberFieldMethod {
676	pub(crate) syntax: SyntaxNode,666	pub(crate) syntax: SyntaxNode,
677}667}
678impl FieldMethod {668impl MemberFieldMethod {
679	pub fn field_name(&self) -> Option<FieldName> {669	pub fn field_name(&self) -> Option<FieldName> {
680		support::child(&self.syntax)670		support::child(&self.syntax)
681	}671	}
955pub enum Member {945pub enum Member {
956	MemberBindStmt(MemberBindStmt),946	MemberBindStmt(MemberBindStmt),
957	MemberAssertStmt(MemberAssertStmt),947	MemberAssertStmt(MemberAssertStmt),
958	MemberField(MemberField),948	MemberFieldNormal(MemberFieldNormal),
949	MemberFieldMethod(MemberFieldMethod),
959}950}
960
961#[derive(Debug, Clone, PartialEq, Eq, Hash)]
962pub enum Field {
963	FieldNormal(FieldNormal),
964	FieldMethod(FieldMethod),
965}
966951
967#[derive(Debug, Clone, PartialEq, Eq, Hash)]952#[derive(Debug, Clone, PartialEq, Eq, Hash)]
968pub enum FieldName {953pub enum FieldName {
1134pub enum ParsingErrorKind {1119pub enum ParsingErrorKind {
1135	ErrorMissingToken,1120	ErrorMissingToken,
1136	ErrorUnexpectedToken,1121	ErrorUnexpectedToken,
1122	ErrorCustom,
1137}1123}
1138impl AstNode for SourceFile {1124impl AstNode for SourceFile {
1139	fn can_cast(kind: SyntaxKind) -> bool {1125	fn can_cast(kind: SyntaxKind) -> bool {
1780		&self.syntax1766		&self.syntax
1781	}1767	}
1782}1768}
1783impl AstNode for MemberField {1769impl AstNode for MemberFieldNormal {
1784	fn can_cast(kind: SyntaxKind) -> bool {1770	fn can_cast(kind: SyntaxKind) -> bool {
1785		kind == MEMBER_FIELD1771		kind == MEMBER_FIELD_NORMAL
1786	}1772	}
1787	fn cast(syntax: SyntaxNode) -> Option<Self> {1773	fn cast(syntax: SyntaxNode) -> Option<Self> {
1788		if Self::can_cast(syntax.kind()) {1774		if Self::can_cast(syntax.kind()) {
1795		&self.syntax1781		&self.syntax
1796	}1782	}
1797}1783}
1798impl AstNode for FieldNormal {1784impl AstNode for MemberFieldMethod {
1799	fn can_cast(kind: SyntaxKind) -> bool {1785	fn can_cast(kind: SyntaxKind) -> bool {
1800		kind == FIELD_NORMAL1786		kind == MEMBER_FIELD_METHOD
1801	}1787	}
1802	fn cast(syntax: SyntaxNode) -> Option<Self> {1788	fn cast(syntax: SyntaxNode) -> Option<Self> {
1803		if Self::can_cast(syntax.kind()) {1789		if Self::can_cast(syntax.kind()) {
1810		&self.syntax1796		&self.syntax
1811	}1797	}
1812}1798}
1813impl AstNode for FieldMethod {
1814	fn can_cast(kind: SyntaxKind) -> bool {
1815		kind == FIELD_METHOD
1816	}
1817	fn cast(syntax: SyntaxNode) -> Option<Self> {
1818		if Self::can_cast(syntax.kind()) {
1819			Some(Self { syntax })
1820		} else {
1821			None
1822		}
1823	}
1824	fn syntax(&self) -> &SyntaxNode {
1825		&self.syntax
1826	}
1827}
1828impl AstNode for FieldNameFixed {1799impl AstNode for FieldNameFixed {
1829	fn can_cast(kind: SyntaxKind) -> bool {1800	fn can_cast(kind: SyntaxKind) -> bool {
1830		kind == FIELD_NAME_FIXED1801		kind == FIELD_NAME_FIXED
2352		Member::MemberAssertStmt(node)2323		Member::MemberAssertStmt(node)
2353	}2324	}
2354}2325}
2355impl From<MemberField> for Member {2326impl From<MemberFieldNormal> for Member {
2356	fn from(node: MemberField) -> Member {2327	fn from(node: MemberFieldNormal) -> Member {
2357		Member::MemberField(node)2328		Member::MemberFieldNormal(node)
2358	}2329	}
2359}2330}
2331impl From<MemberFieldMethod> for Member {
2332	fn from(node: MemberFieldMethod) -> Member {
2333		Member::MemberFieldMethod(node)
2334	}
2335}
2360impl AstNode for Member {2336impl AstNode for Member {
2361	fn can_cast(kind: SyntaxKind) -> bool {2337	fn can_cast(kind: SyntaxKind) -> bool {
2362		match kind {2338		match kind {
2363			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD => true,2339			MEMBER_BIND_STMT | MEMBER_ASSERT_STMT | MEMBER_FIELD_NORMAL | MEMBER_FIELD_METHOD => {
2340				true
2341			}
2364			_ => false,2342			_ => false,
2365		}2343		}
2366	}2344	}
2367	fn cast(syntax: SyntaxNode) -> Option<Self> {2345	fn cast(syntax: SyntaxNode) -> Option<Self> {
2368		let res = match syntax.kind() {2346		let res = match syntax.kind() {
2369			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),2347			MEMBER_BIND_STMT => Member::MemberBindStmt(MemberBindStmt { syntax }),
2370			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),2348			MEMBER_ASSERT_STMT => Member::MemberAssertStmt(MemberAssertStmt { syntax }),
2371			MEMBER_FIELD => Member::MemberField(MemberField { syntax }),2349			MEMBER_FIELD_NORMAL => Member::MemberFieldNormal(MemberFieldNormal { syntax }),
2350			MEMBER_FIELD_METHOD => Member::MemberFieldMethod(MemberFieldMethod { syntax }),
2372			_ => return None,2351			_ => return None,
2373		};2352		};
2374		Some(res)2353		Some(res)
2377		match self {2356		match self {
2378			Member::MemberBindStmt(it) => &it.syntax,2357			Member::MemberBindStmt(it) => &it.syntax,
2379			Member::MemberAssertStmt(it) => &it.syntax,2358			Member::MemberAssertStmt(it) => &it.syntax,
2380			Member::MemberField(it) => &it.syntax,2359			Member::MemberFieldNormal(it) => &it.syntax,
2360			Member::MemberFieldMethod(it) => &it.syntax,
2381		}2361		}
2382	}2362	}
2383}2363}
2384impl From<FieldNormal> for Field {
2385	fn from(node: FieldNormal) -> Field {
2386		Field::FieldNormal(node)
2387	}
2388}
2389impl From<FieldMethod> for Field {
2390	fn from(node: FieldMethod) -> Field {
2391		Field::FieldMethod(node)
2392	}
2393}
2394impl AstNode for Field {
2395	fn can_cast(kind: SyntaxKind) -> bool {
2396		match kind {
2397			FIELD_NORMAL | FIELD_METHOD => true,
2398			_ => false,
2399		}
2400	}
2401	fn cast(syntax: SyntaxNode) -> Option<Self> {
2402		let res = match syntax.kind() {
2403			FIELD_NORMAL => Field::FieldNormal(FieldNormal { syntax }),
2404			FIELD_METHOD => Field::FieldMethod(FieldMethod { syntax }),
2405			_ => return None,
2406		};
2407		Some(res)
2408	}
2409	fn syntax(&self) -> &SyntaxNode {
2410		match self {
2411			Field::FieldNormal(it) => &it.syntax,
2412			Field::FieldMethod(it) => &it.syntax,
2413		}
2414	}
2415}
2416impl From<FieldNameFixed> for FieldName {2364impl From<FieldNameFixed> for FieldName {
2417	fn from(node: FieldNameFixed) -> FieldName {2365	fn from(node: FieldNameFixed) -> FieldName {
2418		FieldName::FieldNameFixed(node)2366		FieldName::FieldNameFixed(node)
2914impl ParsingErrorKind {2862impl ParsingErrorKind {
2915	fn can_cast(kind: SyntaxKind) -> bool {2863	fn can_cast(kind: SyntaxKind) -> bool {
2916		match kind {2864		match kind {
2917			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN => true,2865			ERROR_MISSING_TOKEN | ERROR_UNEXPECTED_TOKEN | ERROR_CUSTOM => true,
2918			_ => false,2866			_ => false,
2919		}2867		}
2920	}2868	}
2921	pub fn cast(kind: SyntaxKind) -> Option<Self> {2869	pub fn cast(kind: SyntaxKind) -> Option<Self> {
2922		let res = match kind {2870		let res = match kind {
2923			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,2871			ERROR_MISSING_TOKEN => Self::ErrorMissingToken,
2924			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,2872			ERROR_UNEXPECTED_TOKEN => Self::ErrorUnexpectedToken,
2873			ERROR_CUSTOM => Self::ErrorCustom,
2925			_ => return None,2874			_ => return None,
2926		};2875		};
2927		Some(res)2876		Some(res)
2962		std::fmt::Display::fmt(self.syntax(), f)2911		std::fmt::Display::fmt(self.syntax(), f)
2963	}2912	}
2964}2913}
2965impl std::fmt::Display for Field {
2966	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2967		std::fmt::Display::fmt(self.syntax(), f)
2968	}
2969}
2970impl std::fmt::Display for FieldName {2914impl std::fmt::Display for FieldName {
2971	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2915	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2972		std::fmt::Display::fmt(self.syntax(), f)2916		std::fmt::Display::fmt(self.syntax(), f)
3197		std::fmt::Display::fmt(self.syntax(), f)3141		std::fmt::Display::fmt(self.syntax(), f)
3198	}3142	}
3199}3143}
3200impl std::fmt::Display for MemberField {3144impl std::fmt::Display for MemberFieldNormal {
3201	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3145	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3202		std::fmt::Display::fmt(self.syntax(), f)3146		std::fmt::Display::fmt(self.syntax(), f)
3203	}3147	}
3204}3148}
3205impl std::fmt::Display for FieldNormal {3149impl std::fmt::Display for MemberFieldMethod {
3206	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3150	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3207		std::fmt::Display::fmt(self.syntax(), f)3151		std::fmt::Display::fmt(self.syntax(), f)
3208	}3152	}
3209}3153}
3210impl std::fmt::Display for FieldMethod {
3211	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3212		std::fmt::Display::fmt(self.syntax(), f)
3213	}
3214}
3215impl std::fmt::Display for FieldNameFixed {3154impl std::fmt::Display for FieldNameFixed {
3216	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {3155	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3217		std::fmt::Display::fmt(self.syntax(), f)3156		std::fmt::Display::fmt(self.syntax(), f)

181	ASSERT_KW,181	ASSERT_KW,
182	ERROR_MISSING_TOKEN,182	ERROR_MISSING_TOKEN,
183	ERROR_UNEXPECTED_TOKEN,183	ERROR_UNEXPECTED_TOKEN,
184	ERROR_CUSTOM,
184	#[doc = r" Also acts as __LAST_TOKEN"]185	#[doc = r" Also acts as __LAST_TOKEN"]
185	#[error]186	#[error]
186	LEXING_ERROR,187	LEXING_ERROR,
227	OBJ_LOCAL,228	OBJ_LOCAL,
228	MEMBER_BIND_STMT,229	MEMBER_BIND_STMT,
229	MEMBER_ASSERT_STMT,230	MEMBER_ASSERT_STMT,
230	MEMBER_FIELD,231	MEMBER_FIELD_NORMAL,
231	FIELD_NORMAL,232	MEMBER_FIELD_METHOD,
232	FIELD_METHOD,
233	FIELD_NAME_FIXED,233	FIELD_NAME_FIXED,
234	FIELD_NAME_DYNAMIC,234	FIELD_NAME_DYNAMIC,
235	FOR_SPEC,235	FOR_SPEC,
249	COMP_SPEC,249	COMP_SPEC,
250	BIND,250	BIND,
251	MEMBER,251	MEMBER,
252	FIELD,
253	FIELD_NAME,252	FIELD_NAME,
254	DESTRUCT,253	DESTRUCT,
255	DESTRUCT_ARRAY_PART,254	DESTRUCT_ARRAY_PART,
281	}280	}
282	pub fn is_enum(self) -> bool {281	pub fn is_enum(self) -> bool {
283		match self {282		match self {
284			EXPR | OBJ_BODY | COMP_SPEC | BIND | MEMBER | FIELD | FIELD_NAME | DESTRUCT283			EXPR | OBJ_BODY | COMP_SPEC | BIND | MEMBER | FIELD_NAME | DESTRUCT
285			| DESTRUCT_ARRAY_PART | BINARY_OPERATOR | UNARY_OPERATOR | LITERAL | TEXT | NUMBER284			| DESTRUCT_ARRAY_PART | BINARY_OPERATOR | UNARY_OPERATOR | LITERAL | TEXT | NUMBER
286			| IMPORT_KIND | VISIBILITY | TRIVIA | PARSING_ERROR => true,285			| IMPORT_KIND | VISIBILITY | TRIVIA | PARSING_ERROR => true,
287			_ => false,286			_ => false,

3use event::Sink;3use event::Sink;
4use generated::nodes::{SourceFile, Trivia};4use generated::nodes::{SourceFile, Trivia};
5use lex::lex;5use lex::lex;
6use parser::{LocatedSyntaxError, Parser, SyntaxError};6use parser::{LocatedSyntaxError, Parser};
7pub use rowan;7pub use rowan;
88
9mod ast;9mod ast;

1use drop_bomb::DropBomb;1use std::num::NonZeroUsize;
2
2use rowan::TextRange;3use drop_bomb::DropBomb;
34
4use crate::{event::Event, parser::Parser, SyntaxKind};5use crate::{
6	event::Event,
7	parser::{ExpectedSyntax, Parser, SyntaxError},
8	SyntaxKind,
9};
510
6pub struct Ranger {11pub struct Ranger {
38			bomb: DropBomb::new("marked dropped while not completed"),43			bomb: DropBomb::new("marked dropped while not completed"),
39		}44		}
40	}45	}
41	pub fn complete(mut self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {46	fn complete_raw(
47		mut self,
48		p: &mut Parser,
49		kind: SyntaxKind,
50		error: Option<SyntaxError>,
51	) -> CompletedMarker {
42		self.bomb.defuse();52		self.bomb.defuse();
43		assert!(53		assert!(
50		// 	"{kind:?} should be only emitted by lexer, not used directly"60		// 	"{kind:?} should be only emitted by lexer, not used directly"
51		// );61		// );
52		let event_at_pos = &mut p.events[self.start_event_idx];62		let event_at_pos = &mut p.events[self.start_event_idx];
53		assert_eq!(*event_at_pos, Event::Pending);63		assert!(matches!(event_at_pos, Event::Pending));
5464
55		*event_at_pos = Event::Start {65		*event_at_pos = Event::Start {
56			kind,66			kind,
5969
60		let finish_event_idx = p.events.len();70		let finish_event_idx = p.events.len();
61		p.events.push(Event::Finish { wrapper: None });71		p.events.push(Event::Finish {
72			wrapper: None,
73			error: error.map(Box::new),
74		});
62		p.entered -= 1;75		p.entered -= 1;
63		p.clear_outdated_hints();76		p.clear_outdated_hints();
66			finish_event_idx,79			finish_event_idx,
67		}80		}
68	}81	}
82	pub fn complete(mut self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
83		self.complete_raw(p, kind, None)
84	}
85	pub fn complete_error(mut self, p: &mut Parser, msg: impl AsRef<str>) -> CompletedMarker {
86		self.complete_raw(
87			p,
88			SyntaxKind::ERROR_CUSTOM,
89			Some(SyntaxError::Custom {
90				error: msg.as_ref().to_owned(),
91			}),
92		)
93	}
94	pub fn complete_missing(mut self, p: &mut Parser, expected: ExpectedSyntax) -> CompletedMarker {
95		self.complete_raw(
96			p,
97			SyntaxKind::ERROR_MISSING_TOKEN,
98			Some(SyntaxError::Missing { expected }),
99		)
100	}
101	pub fn complete_unexpected(
102		mut self,
103		p: &mut Parser,
104		expected: ExpectedSyntax,
105		found: SyntaxKind,
106	) -> CompletedMarker {
107		self.complete_raw(
108			p,
109			SyntaxKind::ERROR_UNEXPECTED_TOKEN,
110			Some(SyntaxError::Unexpected { expected, found }),
111		)
112	}
113
69	pub fn forget(mut self, p: &mut Parser) {114	pub fn forget(mut self, p: &mut Parser) {
70		self.bomb.defuse();115		self.bomb.defuse();
71		let event_at_pos = &mut p.events[self.start_event_idx];116		let event_at_pos = &mut p.events[self.start_event_idx];
72		assert_eq!(*event_at_pos, Event::Pending);117		assert!(matches!(event_at_pos, Event::Pending));
73118
74		*event_at_pos = Event::Noop;119		*event_at_pos = Event::Noop;
75		p.entered -= 1;120		p.entered -= 1;
86		match &mut p.events[self.start_event_idx] {131		match &mut p.events[self.start_event_idx] {
87			Event::Start { forward_parent, .. } => {132			Event::Start { forward_parent, .. } => {
88				*forward_parent = Some(new_m.start_event_idx - self.start_event_idx);133				*forward_parent = Some(
134					NonZeroUsize::new(new_m.start_event_idx - self.start_event_idx).expect("!= 0"),
135				);
89			}136			}
90			_ => unreachable!(),137			_ => unreachable!(),
93		new_m140		new_m
94	}141	}
95	/// Create new node around existing marker, not counting anything that comes after it142	/// Create new node around existing marker, not counting anything that comes after it
96	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {143	fn wrap_raw(
144		self,
145		p: &mut Parser,
146		kind: SyntaxKind,
147		error: Option<SyntaxError>,
148	) -> CompletedMarker {
97		let new_m = p.start();149		let new_m = p.start();
98		match &mut p.events[self.start_event_idx] {150		match &mut p.events[self.start_event_idx] {
99			Event::Start { forward_parent, .. } => {151			Event::Start { forward_parent, .. } => {
100				*forward_parent = Some(new_m.start_event_idx - self.start_event_idx);152				*forward_parent = Some(
153					NonZeroUsize::new(new_m.start_event_idx - self.start_event_idx).expect("!= 0"),
154				);
101			}155			}
102			_ => unreachable!(),156			_ => unreachable!(),
103		}157		}
104158
105		let completed = new_m.complete(p, kind);159		let completed = new_m.complete_raw(p, kind, error);
106160
107		match &mut p.events[self.finish_event_idx] {161		match &mut p.events[self.finish_event_idx] {
108			Event::Finish { wrapper } => {162			Event::Finish {
163				wrapper,
164				error: _error,
165			} => {
109				*wrapper = Some(completed.finish_event_idx - self.finish_event_idx);166				*wrapper = Some(
167					NonZeroUsize::new(completed.finish_event_idx - self.finish_event_idx)
168						.expect("!= 0"),
169				);
110			}170			}
111			_ => unreachable!(),171			_ => unreachable!(),
112		}172		}
113		completed173		completed
114	}174	}
175	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
176		self.wrap_raw(p, kind, None)
177	}
178	pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef<str>) -> CompletedMarker {
179		self.wrap_raw(
180			p,
181			SyntaxKind::ERROR_CUSTOM,
182			Some(SyntaxError::Custom {
183				error: msg.as_ref().to_owned(),
184			}),
185		)
186	}
115}187}
116188

1use std::{cell::Cell, fmt::Display, rc::Rc};1use std::{cell::Cell, fmt, rc::Rc};
22
3use miette::{LabeledSpan, SourceOffset, SourceSpan};3use miette::{LabeledSpan, SourceOffset, SourceSpan};
4use rowan::{GreenNode, TextRange, TextSize};4use rowan::{GreenNode, TextRange};
55
6use crate::{6use crate::{
7	event::Event,7	event::Event,
8	lex::Lexeme,
9	marker::{CompletedMarker, Marker, Ranger},8	marker::{CompletedMarker, Marker, Ranger},
10	nodes::{BinaryOperatorKind, Literal, Number, Text, Trivia, UnaryOperatorKind},9	nodes::{BinaryOperatorKind, Literal, Number, Text, UnaryOperatorKind},
11	token_set::SyntaxKindSet,10	token_set::SyntaxKindSet,
12	AstToken, SyntaxKind,11	AstToken, SyntaxKind,
13	SyntaxKind::*,12	SyntaxKind::*,
19	pub errors: Vec<LocatedSyntaxError>,18	pub errors: Vec<LocatedSyntaxError>,
20}19}
21
22#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
23pub enum ExpectedSyntax {
24	Named(&'static str),
25	Unnamed(SyntaxKind),
26}
27impl Display for ExpectedSyntax {
28	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29		match self {
30			ExpectedSyntax::Named(n) => write!(f, "{}", n),
31			ExpectedSyntax::Unnamed(u) => write!(f, "{:?}", u),
32		}
33	}
34}
3520
36pub struct Parser {21pub struct Parser {
37	// TODO: remove all trivia before feeding to parser?22	// TODO: remove all trivia before feeding to parser?
41	pub entered: u32,26	pub entered: u32,
42	pub hints: Vec<(u32, TextRange, String)>,27	pub hints: Vec<(u32, TextRange, String)>,
43	pub last_error_token: usize,28	pub last_error_token: usize,
44	expected_syntax: Option<ExpectedSyntax>,
45	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,29	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,
46	steps: Cell<u64>,30	steps: Cell<u64>,
47}31}
48
49const DEFAULT_RECOVERY_SET: SyntaxKindSet = TS![];
5032
51#[derive(Clone, Debug, PartialEq, Eq)]33#[derive(Clone, Debug)]
52pub enum SyntaxError {34pub enum SyntaxError {
53	Unexpected {35	Unexpected {
54		expected: ExpectedSyntax,36		expected: ExpectedSyntax,
80		dbg!(&val);62		dbg!(&val);
81		match val.error {63		match val.error {
82			SyntaxError::Unexpected { expected, found } => LabeledSpan::new_with_span(64			SyntaxError::Unexpected { expected, found } => LabeledSpan::new_with_span(
83				Some(format!("expected {}, found {:?}", expected, found)),65				Some(format!("expected {expected}, found {found:?}")),
84				span,66				span,
85			),67			),
86			SyntaxError::Missing { expected } => {68			SyntaxError::Missing { expected } => {
87				LabeledSpan::new_with_span(Some(format!("missing {}", expected)), span)69				LabeledSpan::new_with_span(Some(format!("missing {expected}")), span)
88			}70			}
89			SyntaxError::Custom { error } | SyntaxError::Hint { error } => {71			SyntaxError::Custom { error } | SyntaxError::Hint { error } => {
90				LabeledSpan::new_with_span(Some(error), span)72				LabeledSpan::new_with_span(Some(error), span)
102			entered: 0,84			entered: 0,
103			last_error_token: 0,85			last_error_token: 0,
104			hints: vec![],86			hints: vec![],
105			expected_syntax: None,
106			expected_syntax_tracking_state: Rc::new(Cell::new(87			expected_syntax_tracking_state: Rc::new(Cell::new(ExpectedSyntax::Unnamed(TS![]))),
107				ExpectedSyntaxTrackingState::Unnamed,
108			)),
109			steps: Cell::new(0),88			steps: Cell::new(0),
110		}89		}
119		self.hints.truncate(self.hints.len() - amount)98		self.hints.truncate(self.hints.len() - amount)
120	}99	}
121	fn clear_expected_syntaxes(&mut self) {100	fn clear_expected_syntaxes(&mut self) {
122		self.expected_syntax = None;
123		self.expected_syntax_tracking_state101		self.expected_syntax_tracking_state
124			.set(ExpectedSyntaxTrackingState::Unnamed);102			.set(ExpectedSyntax::Unnamed(TS![]));
125	}103	}
126	pub fn start(&mut self) -> Marker {104	pub fn start(&mut self) -> Marker {
127		let start_event_idx = self.events.len();105		let start_event_idx = self.events.len();
167			self.error_with_no_skip();145			self.error_with_no_skip();
168		}146		}
169	}147	}
170	pub(crate) fn error_with_recovery_set(
171		&mut self,
172		recovery_set: SyntaxKindSet,
173	) -> CompletedMarker {
174		self.error_with_recovery_set_no_default(recovery_set.union(DEFAULT_RECOVERY_SET))
175	}
176	pub fn error_with_no_skip(&mut self) -> CompletedMarker {148	pub fn error_with_no_skip(&mut self) -> CompletedMarker {
177		self.error_with_recovery_set_no_default(SyntaxKindSet::ALL)149		self.error_with_recovery_set(SyntaxKindSet::ALL)
178	}150	}
179151
180	pub fn error_with_recovery_set_no_default(152	pub fn error_with_recovery_set(&mut self, recovery_set: SyntaxKindSet) -> CompletedMarker {
181		&mut self,
182		recovery_set: SyntaxKindSet,
183	) -> CompletedMarker {
184		let expected_syntax = self153		let expected = self.expected_syntax_tracking_state.get();
185			.expected_syntax
186			.take()
187			.unwrap_or(ExpectedSyntax::Named("unknown"));
188		self.expected_syntax_tracking_state154		self.expected_syntax_tracking_state
189			.set(ExpectedSyntaxTrackingState::Unnamed);155			.set(ExpectedSyntax::Unnamed(TS![]));
190156
191		if self.at_end() || self.at_ts(recovery_set) {157		if self.at_end() || self.at_ts(recovery_set) {
192			// let range = self
193			// 	.offset
194			// 	.unwrap_or_else(|| TextRange::at(TextSize::from(0), TextSize::from(0)));
195			let m = self.start();158			let m = self.start();
196			let m = m.complete(self, ERROR_MISSING_TOKEN);159			return m.complete_missing(self, expected);
197			self.events.push(Event::Error(SyntaxError::Missing {
198				expected: expected_syntax,
199			}));
200			return m;
201		}160		}
202161
203		let current_token = self.current();162		let current_token = self.current();
206165
207		let m = self.start();166		let m = self.start();
208		self.bump();167		self.bump();
209		let m = m.complete(self, ERROR_UNEXPECTED_TOKEN);168		let m = m.complete_unexpected(self, expected, current_token);
210		self.events.push(Event::Error(SyntaxError::Unexpected {
211			expected: expected_syntax,
212			found: current_token,
213		}));
214		self.clear_expected_syntaxes();169		self.clear_expected_syntaxes();
215		m170		m
216	}171	}
269	#[must_use]224	#[must_use]
270	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {225	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {
271		self.expected_syntax_tracking_state226		self.expected_syntax_tracking_state
272			.set(ExpectedSyntaxTrackingState::Named);227			.set(ExpectedSyntax::Named(name));
273		self.expected_syntax = Some(ExpectedSyntax::Named(name));
274228
275		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))229		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))
276	}230	}
277	pub fn at(&mut self, kind: SyntaxKind) -> bool {231	pub fn at(&mut self, kind: SyntaxKind) -> bool {
278		self.nth_at(0, kind)232		self.nth_at(0, kind)
279	}233	}
280	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {234	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {
281		if let ExpectedSyntaxTrackingState::Unnamed = self.expected_syntax_tracking_state.get() {235		if n == 0 {
236			if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {
237				let kinds = kinds.with(kind);
282			self.expected_syntax = Some(ExpectedSyntax::Unnamed(kind));238				self.expected_syntax_tracking_state
239					.set(ExpectedSyntax::Unnamed(kinds))
283		}240			}
241		}
284		self.nth(n) == kind242		self.nth(n) == kind
285	}243	}
286	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {244	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {
245		if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {
246			let kinds = kinds.union(set);
247			self.expected_syntax_tracking_state
248				.set(ExpectedSyntax::Unnamed(kinds))
249		}
287		set.contains(self.current())250		set.contains(self.current())
288	}251	}
289	pub fn at_end(&mut self) -> bool {252	pub fn at_end(&mut self) -> bool {
290		self.at(EOF)253		self.at(EOF)
291	}254	}
292}255}
293pub(crate) struct ExpectedSyntaxGuard {256pub(crate) struct ExpectedSyntaxGuard {
294	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,257	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,
295}258}
296259
297impl ExpectedSyntaxGuard {260impl ExpectedSyntaxGuard {
298	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>) -> Self {261	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>) -> Self {
299		Self {262		Self {
300			expected_syntax_tracking_state,263			expected_syntax_tracking_state,
301		}264		}
305impl Drop for ExpectedSyntaxGuard {268impl Drop for ExpectedSyntaxGuard {
306	fn drop(&mut self) {269	fn drop(&mut self) {
307		self.expected_syntax_tracking_state270		self.expected_syntax_tracking_state
308			.set(ExpectedSyntaxTrackingState::Unnamed);271			.set(ExpectedSyntax::Unnamed(TS![]));
309	}272	}
310}273}
311274
312#[derive(Debug, Clone, Copy)]275#[derive(Clone, Debug, Copy)]
313enum ExpectedSyntaxTrackingState {276pub enum ExpectedSyntax {
314	Named,277	Named(&'static str),
315	Unnamed,278	Unnamed(SyntaxKindSet),
316}279}
280impl fmt::Display for ExpectedSyntax {
281	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
282		match self {
283			ExpectedSyntax::Named(name) => write!(f, "{name}"),
284			ExpectedSyntax::Unnamed(set) => write!(f, "{set}"),
285		}
286	}
287}
317288
318fn expr(p: &mut Parser) -> CompletedMarker {289fn expr(p: &mut Parser) -> CompletedMarker {
319	match expr_binding_power(p, 0) {290	match expr_binding_power(p, 0) {
358	Ok(lhs)329	Ok(lhs)
359}330}
331
332const COMPSPEC: SyntaxKindSet = TS![for if];
360fn compspec(p: &mut Parser) {333fn compspec(p: &mut Parser) -> CompletedMarker {
361	assert!(p.at(T![for]) || p.at(T![if]));334	assert!(p.at_ts(COMPSPEC));
362	if p.at(T![for]) {335	if p.at(T![for]) {
363		let m = p.start();336		let m = p.start();
364		p.bump();337		p.bump();
365		name(p);338		name(p);
366		p.expect(T![in]);339		p.expect(T![in]);
367		expr(p);340		expr(p);
368		m.complete(p, FOR_SPEC);341		m.complete(p, FOR_SPEC)
369	} else if p.at(T![if]) {342	} else if p.at(T![if]) {
370		let m = p.start();343		let m = p.start();
371		p.bump();344		p.bump();
372		expr(p);345		expr(p);
373		m.complete(p, IF_SPEC);346		m.complete(p, IF_SPEC)
374	} else {347	} else {
375		unreachable!()348		unreachable!()
376	}349	}
377}350}
351
378fn comma(p: &mut Parser) -> bool {352fn comma(p: &mut Parser) -> bool {
379	if p.at(T![,]) {353	comma_with_alternatives(p, TS![])
380		p.bump();
381		true
382	} else {
383		false
384	}
385}354}
386fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {355fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {
387	if p.at(T![,]) {356	if p.at(T![,]) {
388		p.bump();357		p.bump();
389		true358		true
390	} else if p.at_ts(set) {359	} else if p.at_ts(set) {
391		p.expect_with_no_skip(T![,]);360		let _ex = p.expected_syntax_name("comma");
392		p.bump();361		p.expect_with_recovery_set(T![,], TS![]);
393		true362		true
394	} else {363	} else {
395		false364		false
410		text(p);380		text(p);
411		m.complete(p, FIELD_NAME_FIXED);381		m.complete(p, FIELD_NAME_FIXED);
412	} else {382	} else {
383		m.forget(p);
413		p.error_with_recovery_set(TS![;]);384		p.error_with_recovery_set(TS![; : :: ::: '(']);
414	}385	}
415}386}
416fn visibility(p: &mut Parser) {387fn visibility(p: &mut Parser) {
417	if p.at_ts(TS![: :: :::]) {388	if p.at_ts(TS![: :: :::]) {
418		p.bump()389		p.bump()
419	} else {390	} else {
420		p.error_with_recovery_set(TS![]);391		p.error_with_recovery_set(TS![=]);
421	}392	}
422}393}
423fn field(p: &mut Parser) {
424	let m = p.start();
425	field_name(p);
426	let plus = if p.at(T![+]) {
427		let r = p.start_ranger();
428		p.bump();
429		Some(r.finish(p))
430	} else {
431		None
432	};
433	let params = if p.at(T!['(']) {
434		// if let Some(plus) = plus {
435		// 	p.custom_error(plus, "can't extend with method");
436		// }
437		params_desc(p);
438		// if p.at(T![+]) {
439		// 	let r = p.start_ranger();
440		// 	p.bump();
441		// 	p.custom_error(r.finish(p), "can't extend with method");
442		// }
443		true
444	} else {
445		false
446	};
447	visibility(p);
448	expr(p);
449
450	if params {
451		m.complete(p, FIELD_METHOD)
452	} else {
453		m.complete(p, FIELD_NORMAL)
454	};
455}
456fn assertion(p: &mut Parser) {394fn assertion(p: &mut Parser) {
457	let m = p.start();395	let m = p.start();
458	p.bump_assert(T![assert]);396	p.bump_assert(T![assert]);
468	let m = p.start();406	let m = p.start();
469	p.bump_assert(T!['{']);407	p.bump_assert(T!['{']);
470408
409	let mut elems = 0;
410	let mut compspecs = Vec::new();
471	loop {411	loop {
472		if p.at(T!['}']) {412		if p.at(T!['}']) {
473			p.bump();413			p.bump();
474			break;414			break;
475		}415		}
416		if p.at_ts(COMPSPEC) {
417			if elems == 0 {
418				let m = p.start();
419				m.complete_missing(p, ExpectedSyntax::Named("field definition"));
420			}
421			while p.at_ts(COMPSPEC) {
422				compspecs.push(compspec(p));
423			}
424			if comma_with_alternatives(p, TS![;]) {
425				continue;
426			}
427			p.expect(R_BRACE);
428			break;
429		}
476		let m = p.start();430		let m = p.start();
477		if p.at(T![local]) {431		if p.at(T![local]) {
478			obj_local(p);432			obj_local(p);
481			assertion(p);435			assertion(p);
482			m.complete(p, MEMBER_ASSERT_STMT)436			m.complete(p, MEMBER_ASSERT_STMT)
483		} else {437		} else {
484			field(p);438			field_name(p);
439			if p.at(T![+]) {
440				p.bump();
441			}
485			while p.at(T![for]) || p.at(T![if]) {442			let params = if p.at(T!['(']) {
486				compspec(p)443				params_desc(p);
487			}444				visibility(p);
445				expr(p);
446				true
447			} else if p.at_ts(TS![: :: :::]) && p.nth_at(1, T![function]) {
448				visibility(p);
449				p.bump_assert(T![function]);
450				params_desc(p);
451				expr(p);
452				true
453			} else {
454				visibility(p);
455				expr(p);
456				false
457			};
458
459			if params {
488			m.complete(p, MEMBER_FIELD)460				m.complete(p, MEMBER_FIELD_METHOD)
461			} else {
462				m.complete(p, MEMBER_FIELD_NORMAL)
463			}
489		};464		};
465		elems += 1;
466		while p.at_ts(COMPSPEC) {
467			compspecs.push(compspec(p));
468		}
490		if comma_with_alternatives(p, SyntaxKindSet::new(&[T![=]])) {469		if comma_with_alternatives(p, TS![;]) {
491			continue;470			continue;
492		}471		}
493		p.expect(R_BRACE);472		p.expect(R_BRACE);
494		break;473		break;
495	}474	}
496475
476	if elems > 1 && !compspecs.is_empty() {
477		for errored in compspecs {
478			errored.wrap_error(
479				p,
480				"compspec may only be used if there is only one array element",
481			);
482		}
497	m.complete(p, OBJ_BODY_MEMBER_LIST);483		m.complete(p, OBJ_BODY_MEMBER_LIST);
484	} else if !compspecs.is_empty() {
485		m.complete(p, OBJ_BODY_COMP);
486	} else {
487		m.complete(p, OBJ_BODY_MEMBER_LIST);
488	}
498	m_t.complete(p, EXPR_OBJECT)489	m_t.complete(p, EXPR_OBJECT)
499}490}
500fn param(p: &mut Parser) {491fn param(p: &mut Parser) {
530	p.bump_assert(T!['(']);521	p.bump_assert(T!['(']);
531522
532	let started_named = Cell::new(false);523	let started_named = Cell::new(false);
524	let mut unnamed_after_named = Vec::new();
533525
534	loop {526	loop {
535		if p.at(T![')']) {527		if p.at(T![')']) {
545			started_named.set(true);537			started_named.set(true);
546		} else {538		} else {
547			expr(p);539			expr(p);
548			m.complete(p, ARG);540			let arg = m.complete(p, ARG);
541			if started_named.get() {
542				unnamed_after_named.push(arg)
543			}
549		}544		}
550		if comma(p) {545		if comma(p) {
551			continue;546			continue;
557		p.bump()552		p.bump()
558	}553	}
554
555	for errored in unnamed_after_named {
556		errored.wrap_error(p, "can't use positional arguments after named");
557	}
558
559	m.complete(p, ARGS_DESC);559	m.complete(p, ARGS_DESC);
560}560}
564	let m = p.start();564	let m = p.start();
565	p.bump_assert(T!['[']);565	p.bump_assert(T!['[']);
566566
567	// This vec will have at most one element in case of correct input
568	let mut compspecs = Vec::with_capacity(1);567	let mut compspecs = Vec::new();
569	let mut elems = 0;568	let mut elems = 0;
570569
571	loop {570	loop {
572		if p.at(T![']']) {571		if p.at(T![']']) {
573			p.bump();572			p.bump();
574			break;573			break;
575		}574		}
576		elems += 1;
577		expr(p);575		if elems != 0 && p.at_ts(COMPSPEC) {
578		let c = p.start_ranger();576			while p.at_ts(COMPSPEC) {
579		let mut had_spec = false;577				compspecs.push(compspec(p));
578			}
580		while p.at(T![for]) || p.at(T![if]) {579			if comma(p) {
580				continue;
581			}
582			p.expect(T![']']);
583			break;
584		}
581			had_spec = true;585		elems += 1;
582			compspec(p)586		expr(p);
583		}
584		if had_spec {587		while p.at_ts(COMPSPEC) {
585			compspecs.push(c.finish(p));588			compspecs.push(compspec(p));
586		}589		}
587		if comma(p) {590		if comma(p) {
588			continue;591			continue;
593596
594	if elems > 1 && !compspecs.is_empty() {597	if elems > 1 && !compspecs.is_empty() {
595		for spec in compspecs {598		for spec in compspecs {
596			// p.custom_error(599			spec.wrap_error(
597			// 	spec,600				p,
598			// 	"compspec may only be used if there is only one array element",601				"compspec may only be used if there is only one array element",
599			// )602			);
600		}603		}
601604
602		m.complete(p, EXPR_ARRAY)605		m.complete(p, EXPR_ARRAY)