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

1use std::{cell::Cell, fmt::Display, rc::Rc};23use miette::{LabeledSpan, SourceOffset, SourceSpan};4use rowan::{GreenNode, TextRange, TextSize};56use crate::{7	binary::BinaryOperator,8	event::Event,9	lex::Lexeme,10	marker::{AsRange, CompletedMarker, Marker, Ranger},11	nodes::{Literal, Number, Text, Trivia},12	token_set::SyntaxKindSet,13	unary::UnaryOperator,14	AstToken, SyntaxKind,15	SyntaxKind::*,16	SyntaxNode, T, TS,17};1819pub struct Parse {20	pub green_node: GreenNode,21	pub errors: Vec<SyntaxError>,22}2324#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]25pub enum ExpectedSyntax {26	Named(&'static str),27	Unnamed(SyntaxKind),28}29impl Display for ExpectedSyntax {30	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {31		match self {32			ExpectedSyntax::Named(n) => write!(f, "{}", n),33			ExpectedSyntax::Unnamed(u) => write!(f, "{:?}", u),34		}35	}36}3738pub struct Parser<'i> {39	// TODO: remove all trivia before feeding to parser?40	lexemes: &'i [Lexeme<'i>],41	pub offset: usize,42	pub events: Vec<Event>,43	pub entered: u32,44	pub hints: Vec<(u32, TextRange, String)>,45	pub last_error_token: usize,46	expected_syntax: Option<ExpectedSyntax>,47	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,48	steps: Cell<u64>,49}5051const DEFAULT_RECOVERY_SET: SyntaxKindSet = TS![];5253#[derive(Clone, Debug, PartialEq, Eq)]54pub enum SyntaxError {55	Unexpected {56		expected: ExpectedSyntax,57		found: SyntaxKind,58		range: TextRange,59	},60	Missing {61		expected: ExpectedSyntax,62		offset: TextSize,63	},64	Custom {65		error: String,66		range: TextRange,67	},68	Hint {69		error: String,70		range: TextRange,71	},72}7374impl From<SyntaxError> for LabeledSpan {75	fn from(val: SyntaxError) -> Self {76		match val {77			SyntaxError::Unexpected {78				expected,79				found,80				range,81			} => LabeledSpan::new_with_span(82				Some(format!("expected {}, found {:?}", expected, found)),83				SourceSpan::new(84					SourceOffset::from(usize::from(range.start())),85					SourceOffset::from(usize::from(range.end() - range.start())),86				),87			),88			SyntaxError::Missing { expected, offset } => LabeledSpan::new_with_span(89				Some(format!("missing {}", expected)),90				SourceSpan::new(91					SourceOffset::from(usize::from(offset)),92					SourceOffset::from(0),93				),94			),95			SyntaxError::Custom { error, range } | SyntaxError::Hint { error, range } => {96				LabeledSpan::new_with_span(97					Some(error),98					SourceSpan::new(99						SourceOffset::from(usize::from(range.start())),100						SourceOffset::from(usize::from(range.end() - range.start())),101					),102				)103			}104		}105	}106}107108impl<'i> Parser<'i> {109	pub fn new(lexemes: &'i [Lexeme<'i>]) -> Self {110		Self {111			lexemes,112			offset: 0,113			events: vec![],114			entered: 0,115			last_error_token: 0,116			hints: vec![],117			expected_syntax: None,118			expected_syntax_tracking_state: Rc::new(Cell::new(119				ExpectedSyntaxTrackingState::Unnamed,120			)),121			steps: Cell::new(0),122		}123	}124	pub fn clear_outdated_hints(&mut self) {125		let amount = self126			.hints127			.iter()128			.rev()129			.take_while(|h| h.0 > self.entered)130			.count();131		self.hints.truncate(self.hints.len() - amount)132	}133	fn clear_expected_syntaxes(&mut self) {134		self.expected_syntax = None;135		self.expected_syntax_tracking_state136			.set(ExpectedSyntaxTrackingState::Unnamed);137	}138	pub fn start(&mut self) -> Marker {139		self.skip_trivia();140		let start_event_idx = self.events.len();141		self.events.push(Event::Pending);142		self.entered += 1;143		Marker::new(start_event_idx)144	}145	pub fn start_ranger(&mut self) -> Ranger {146		self.skip_trivia();147		let pos = self.offset;148		Ranger { pos }149	}150	pub fn parse(mut self) -> Vec<Event> {151		let m = self.start();152		expr(&mut self);153		self.expect(EOF);154		m.complete(&mut self, SOURCE_FILE);155156		self.events157	}158159	pub(crate) fn expect(&mut self, kind: SyntaxKind) {160		self.expect_with_recovery_set(kind, TS![])161	}162163	pub(crate) fn expect_with_recovery_set(164		&mut self,165		kind: SyntaxKind,166		recovery_set: SyntaxKindSet,167	) {168		if self.at(kind) {169			if kind != EOF {170				self.bump();171			}172		} else {173			self.error_with_recovery_set(recovery_set);174		}175	}176177	pub(crate) fn expect_with_no_skip(&mut self, kind: SyntaxKind) {178		if self.at(kind) {179			self.bump();180		} else {181			self.error_with_no_skip();182		}183	}184	fn current_token(&self) -> Lexeme<'i> {185		self.lexemes[self.offset]186	}187	fn previous_token(&mut self) -> Option<Lexeme<'i>> {188		if self.offset == 0 {189			return None;190		}191		let mut previous_token_idx = self.offset - 1;192		while self193			.lexemes194			.get(previous_token_idx)195			.map_or(false, |l| Trivia::can_cast(l.kind))196			&& previous_token_idx != 0197		{198			previous_token_idx -= 1;199		}200201		Some(self.lexemes[previous_token_idx])202	}203	pub fn start_of_token(&self, mut idx: usize) -> TextSize {204		while Trivia::can_cast(self.lexemes[idx].kind) {205			idx += 1;206		}207		self.lexemes[idx].range.start()208	}209	pub fn end_of_token(&self, mut idx: usize) -> TextSize {210		while Trivia::can_cast(self.lexemes[idx].kind) {211			idx -= 1;212		}213		self.lexemes[idx].range.end()214	}215	pub(crate) fn custom_error(&mut self, marker: impl AsRange, error: impl AsRef<str>) {216		self.last_error_token = marker.end_token();217		self.events.push(Event::Error(SyntaxError::Custom {218			error: error.as_ref().to_string(),219			range: marker.as_range(self),220		}));221	}222	pub(crate) fn error_with_recovery_set(223		&mut self,224		recovery_set: SyntaxKindSet,225	) -> Option<CompletedMarker> {226		self.error_with_recovery_set_no_default(recovery_set.union(DEFAULT_RECOVERY_SET))227	}228	pub fn error_with_no_skip(&mut self) -> Option<CompletedMarker> {229		self.error_with_recovery_set_no_default(SyntaxKindSet::ALL)230	}231232	pub fn error_with_recovery_set_no_default(233		&mut self,234		recovery_set: SyntaxKindSet,235	) -> Option<CompletedMarker> {236		let expected_syntax = self237			.expected_syntax238			.take()239			.unwrap_or(ExpectedSyntax::Named("unknown"));240		self.expected_syntax_tracking_state241			.set(ExpectedSyntaxTrackingState::Unnamed);242243		self.skip_trivia();244		if self.at_end() || self.at_ts(recovery_set) {245			let range = self246				.previous_token()247				.map(|t| t.range)248				.unwrap_or_else(|| TextRange::at(TextSize::from(0), TextSize::from(0)));249250			self.events.push(Event::Error(SyntaxError::Missing {251				expected: expected_syntax,252				offset: range.end(),253			}));254			return None;255		}256257		let current_token = self.current_token();258259		self.events.push(Event::Error(SyntaxError::Unexpected {260			expected: expected_syntax,261			found: current_token.kind,262			range: current_token.range,263		}));264		self.clear_expected_syntaxes();265		self.last_error_token = self.offset;266267		let m = self.start();268		self.bump();269		Some(m.complete(self, SyntaxKind::ERROR))270	}271	fn bump_assert(&mut self, kind: SyntaxKind) {272		self.skip_trivia();273		assert!(self.at(kind), "expected {:?}", kind);274		self.bump_remap(self.current());275	}276	fn bump(&mut self) {277		self.skip_trivia();278		self.bump_remap(self.current());279	}280	fn bump_remap(&mut self, kind: SyntaxKind) {281		self.skip_trivia();282		assert_ne!(self.offset, self.lexemes.len(), "already at end");283		self.events.push(Event::Token { kind });284		self.offset += 1;285		self.clear_expected_syntaxes();286	}287	fn step(&self) {288		use std::fmt::Write;289		let steps = self.steps.get();290		if steps >= 15000000 {291			let mut out = "seems like parsing is stuck".to_owned();292			{293				let last = 20;294				write!(out, "\n\nLast {} events:", last).unwrap();295				for (i, event) in self296					.events297					.iter()298					.skip(self.events.len().saturating_sub(last))299					.enumerate()300				{301					write!(out, "\n{i}. {event:?}").unwrap();302				}303			}304			{305				let next = 20;306				write!(out, "\n\nNext {next} tokens:").unwrap();307				for (i, tok) in self.lexemes.iter().skip(self.offset).take(next).enumerate() {308					write!(out, "\n{i}. {tok:?}").unwrap();309				}310			}311			panic!("{out}")312		}313		self.steps.set(steps + 1);314	}315	fn nth(&self, i: usize) -> SyntaxKind {316		self.step();317		let mut offset = self.offset;318		for _ in 0..i {319			while self320				.lexemes321				.get(offset)322				.map(|l| Trivia::can_cast(l.kind))323				.unwrap_or(false)324			{325				offset += 1;326			}327			offset += 1;328		}329		while self330			.lexemes331			.get(offset)332			.map(|l| Trivia::can_cast(l.kind))333			.unwrap_or(false)334		{335			offset += 1;336		}337		self.lexemes.get(offset).map(|l| l.kind).unwrap_or(EOF)338	}339	fn current(&self) -> SyntaxKind {340		self.nth(0)341	}342	fn skip_trivia(&mut self) {343		while Trivia::can_cast(self.peek_raw()) {344			self.offset += 1;345		}346	}347	fn peek_raw(&mut self) -> SyntaxKind {348		self.lexemes349			.get(self.offset)350			.map(|l| l.kind)351			.unwrap_or(SyntaxKind::EOF)352	}353	#[must_use]354	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {355		self.expected_syntax_tracking_state356			.set(ExpectedSyntaxTrackingState::Named);357		self.expected_syntax = Some(ExpectedSyntax::Named(name));358359		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))360	}361	pub fn at(&mut self, kind: SyntaxKind) -> bool {362		self.nth_at(0, kind)363	}364	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {365		if let ExpectedSyntaxTrackingState::Unnamed = self.expected_syntax_tracking_state.get() {366			self.expected_syntax = Some(ExpectedSyntax::Unnamed(kind));367		}368		self.nth(n) == kind369	}370	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {371		set.contains(self.current())372	}373	pub fn at_end(&mut self) -> bool {374		self.at(EOF)375	}376}377pub(crate) struct ExpectedSyntaxGuard {378	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,379}380381impl ExpectedSyntaxGuard {382	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>) -> Self {383		Self {384			expected_syntax_tracking_state,385		}386	}387}388389impl Drop for ExpectedSyntaxGuard {390	fn drop(&mut self) {391		self.expected_syntax_tracking_state392			.set(ExpectedSyntaxTrackingState::Unnamed);393	}394}395396#[derive(Debug, Clone, Copy)]397enum ExpectedSyntaxTrackingState {398	Named,399	Unnamed,400}401macro_rules! at_match {402	($p:ident {403		$($r:expr => $e:expr,)*404		_ => $else:expr $(,)?405	}) => {{406		$(407			if $p.at($r) {$e} else408		)* {409			$else410		}411	}}412}413414fn expr(p: &mut Parser) -> Option<CompletedMarker> {415	expr_binding_power(p, 0)416}417fn expr_binding_power(p: &mut Parser, minimum_binding_power: u8) -> Option<CompletedMarker> {418	let mut lhs = lhs(p)?;419420	loop {421		let op = at_match!(p {422			T![*] => BinaryOperator::Mul,423			T![/] => BinaryOperator::Div,424			T![%] => BinaryOperator::Mod,425			T![+] => BinaryOperator::Plus,426			T![-] => BinaryOperator::Minus,427			T![<<] => BinaryOperator::ShiftLeft,428			T![>>] => BinaryOperator::ShiftRight,429			T![<] => BinaryOperator::LessThan,430			T![>] => BinaryOperator::GreaterThan,431			T![<=] => BinaryOperator::LessThanOrEqual,432			T![>=] => BinaryOperator::GreaterThanOrEqual,433			T![==] => BinaryOperator::Equal,434			T![!=] => BinaryOperator::NotEqual,435			T![&] => BinaryOperator::BitAnd,436			T![^] => BinaryOperator::BitXor,437			T![|] => BinaryOperator::BitOr,438			T![&&] => BinaryOperator::And,439			T![||] => BinaryOperator::Or,440			T![in] => BinaryOperator::In,441			T!['{'] => BinaryOperator::ObjectApply,442			_ => break,443		});444		let (left_binding_power, right_binding_power) = op.binding_power();445		if left_binding_power < minimum_binding_power {446			break;447		}448449		// Object apply is not a real operator, we dont have something to bump450		if op != BinaryOperator::ObjectApply {451			p.bump();452		}453454		let m = lhs.wrap(p, LHS_EXPR).precede(p);455		let parsed_rhs = expr_binding_power(p, right_binding_power).is_some();456		lhs = m.complete(457			p,458			if op == BinaryOperator::ObjectApply {459				EXPR_OBJ_EXTEND460			} else {461				EXPR_BINARY462			},463		);464465		if !parsed_rhs {466			break;467		}468	}469	Some(lhs)470}471fn compspec(p: &mut Parser) {472	assert!(p.at(T![for]) || p.at(T![if]));473	if p.at(T![for]) {474		let m = p.start();475		p.bump();476		name(p);477		p.expect(T![in]);478		expr(p);479		m.complete(p, FOR_SPEC);480	} else if p.at(T![if]) {481		let m = p.start();482		p.bump();483		expr(p);484		m.complete(p, IF_SPEC);485	} else {486		unreachable!()487	}488}489fn comma(p: &mut Parser) -> bool {490	if p.at(T![,]) {491		p.bump();492		true493	} else {494		false495	}496}497fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {498	if p.at(T![,]) {499		p.bump();500		true501	} else if p.at_ts(set) {502		p.expect_with_no_skip(T![,]);503		p.bump();504		true505	} else {506		false507	}508}509fn field_name(p: &mut Parser) {510	let _e = p.expected_syntax_name("field name");511	let m = p.start();512	if p.at(T!['[']) {513		p.bump();514		expr(p);515		p.expect(T![']']);516		m.complete(p, FIELD_NAME_DYNAMIC);517	} else if p.at(IDENT) {518		name(p);519		m.complete(p, FIELD_NAME_FIXED);520	} else if Text::can_cast(p.current()) {521		text(p);522		m.complete(p, FIELD_NAME_FIXED);523	} else {524		p.error_with_recovery_set(TS![;]);525	}526}527fn visibility(p: &mut Parser) {528	if p.at_ts(TS![: :: :::]) {529		p.bump()530	} else {531		p.error_with_recovery_set(TS![]);532	}533}534fn field(p: &mut Parser) {535	let m = p.start();536	field_name(p);537	let plus = if p.at(T![+]) {538		let r = p.start_ranger();539		p.bump();540		Some(r.finish(p))541	} else {542		None543	};544	let params = if p.at(T!['(']) {545		if let Some(plus) = plus {546			p.custom_error(plus, "can't extend with method");547		}548		params_desc(p);549		if p.at(T![+]) {550			let r = p.start_ranger();551			p.bump();552			p.custom_error(r.finish(p), "can't extend with method");553		}554		true555	} else {556		false557	};558	visibility(p);559	expr(p);560561	if params {562		m.complete(p, FIELD_METHOD)563	} else {564		m.complete(p, FIELD_NORMAL)565	};566}567fn assertion(p: &mut Parser) {568	let m = p.start();569	p.bump_assert(T![assert]);570	expr(p).map(|c| c.wrap(p, LHS_EXPR));571	if p.at(T![:]) {572		p.bump();573		expr(p);574	}575	m.complete(p, ASSERTION);576}577fn object(p: &mut Parser) -> CompletedMarker {578	let m_t = p.start();579	let m = p.start();580	p.bump_assert(T!['{']);581582	loop {583		if p.at(T!['}']) {584			p.bump();585			break;586		}587		let m = p.start();588		if p.at(T![local]) {589			obj_local(p);590			m.complete(p, MEMBER_BIND_STMT)591		} else if p.at(T![assert]) {592			assertion(p);593			m.complete(p, MEMBER_ASSERT_STMT)594		} else {595			field(p);596			while p.at(T![for]) || p.at(T![if]) {597				compspec(p)598			}599			m.complete(p, MEMBER_FIELD)600		};601		if comma_with_alternatives(p, SyntaxKindSet::new(&[T![=]])) {602			continue;603		}604		p.expect(R_BRACE);605		break;606	}607608	m.complete(p, OBJ_BODY_MEMBER_LIST);609	m_t.complete(p, EXPR_OBJECT)610}611fn param(p: &mut Parser) {612	let m = p.start();613	destruct(p);614	if p.at(T![=]) {615		p.bump();616		expr(p);617	}618	m.complete(p, PARAM);619}620fn params_desc(p: &mut Parser) -> CompletedMarker {621	let m = p.start();622	p.bump_assert(T!['(']);623624	loop {625		if p.at(T![')']) {626			p.bump();627			break;628		}629		param(p);630		if comma(p) {631			continue;632		}633		p.expect(T![')']);634		break;635	}636637	m.complete(p, PARAMS_DESC)638}639fn args_desc(p: &mut Parser) {640	let m = p.start();641	p.bump_assert(T!['(']);642643	let started_named = Cell::new(false);644645	loop {646		if p.at(T![')']) {647			break;648		}649650		let m = p.start();651		if p.at(IDENT) && p.nth_at(1, T![=]) {652			name(p);653			p.bump();654			expr(p);655			m.complete(p, ARG);656			started_named.set(true);657		} else {658			expr(p);659			m.complete(p, ARG);660		}661		if comma(p) {662			continue;663		}664		break;665	}666	p.expect(T![')']);667	if p.at(T![tailstrict]) {668		p.bump()669	}670	m.complete(p, ARGS_DESC);671}672673fn array(p: &mut Parser) -> CompletedMarker {674	// Start the list node675	let m = p.start();676	p.bump_assert(T!['[']);677678	// This vec will have at most one element in case of correct input679	let mut compspecs = Vec::with_capacity(1);680	let mut elems = 0;681682	loop {683		if p.at(T![']']) {684			p.bump();685			break;686		}687		elems += 1;688		expr(p);689		let c = p.start_ranger();690		let mut had_spec = false;691		while p.at(T![for]) || p.at(T![if]) {692			had_spec = true;693			compspec(p)694		}695		if had_spec {696			compspecs.push(c.finish(p));697		}698		if comma(p) {699			continue;700		}701		p.expect(T![']']);702		break;703	}704705	if elems > 1 && !compspecs.is_empty() {706		for spec in compspecs {707			p.custom_error(708				spec,709				"compspec may only be used if there is only one array element",710			)711		}712713		m.complete(p, EXPR_ARRAY)714	} else if !compspecs.is_empty() {715		m.complete(p, EXPR_ARRAY_COMP)716	} else {717		m.complete(p, EXPR_ARRAY)718	}719}720/// Returns true if it was slice, false if just index721#[must_use]722fn slice_desc_or_index(p: &mut Parser) -> bool {723	let m = p.start();724	p.bump();725	// TODO: do not treat :, ::, ::: as full tokens?726	// Start727	if !p.at(T![:]) && !p.at(T![::]) {728		expr(p);729	}730	if p.at(T![:]) {731		p.bump();732		// End733		if !p.at(T![']']) {734			expr(p).map(|c| c.wrap(p, SLICE_DESC_END));735		}736		if p.at(T![:]) {737			p.bump();738			// Step739			if !p.at(T![']']) {740				expr(p).map(|c| c.wrap(p, SLICE_DESC_STEP));741			}742		}743	} else if p.at(T![::]) {744		p.bump();745		// End746		if !p.at(T![']']) {747			expr(p).map(|c| c.wrap(p, SLICE_DESC_END));748		}749	} else {750		// It was not a slice751		p.expect(T![']']);752		m.forget(p);753		return false;754	}755	p.expect(T![']']);756	m.complete(p, SLICE_DESC);757	true758}759fn lhs(p: &mut Parser) -> Option<CompletedMarker> {760	let mut lhs = lhs_basic(p)?;761762	loop {763		if p.at(T![.]) {764			let m = lhs.precede(p);765			p.bump();766			name(p);767			lhs = m.complete(p, EXPR_INDEX);768		} else if p.at(T!['[']) {769			if slice_desc_or_index(p) {770				lhs = lhs.precede(p).complete(p, EXPR_SLICE);771			} else {772				lhs = lhs773					.wrap(p, LHS_EXPR)774					.precede(p)775					.complete(p, EXPR_INDEX_EXPR);776			}777		} else if p.at(T!['(']) {778			let m = lhs.precede(p);779			args_desc(p);780			lhs = m.complete(p, EXPR_APPLY);781		} else {782			break;783		}784	}785786	Some(lhs)787}788fn name(p: &mut Parser) {789	let m = p.start();790	p.expect(IDENT);791	m.complete(p, NAME);792}793fn destruct_rest(p: &mut Parser) {794	let m = p.start();795	p.bump_assert(T![...]);796	if p.at(IDENT) {797		p.bump()798	}799	m.complete(p, DESTRUCT_REST);800}801fn destruct_object_field(p: &mut Parser) {802	let m = p.start();803	name(p);804	if p.at(T![:]) {805		p.bump();806		destruct(p);807	};808	if p.at(T![=]) {809		p.bump();810		expr(p);811	}812	m.complete(p, DESTRUCT_OBJECT_FIELD);813}814fn obj_local(p: &mut Parser) {815	let m = p.start();816	p.bump_assert(T![local]);817	bind(p);818	m.complete(p, OBJ_LOCAL);819}820fn destruct(p: &mut Parser) -> CompletedMarker {821	let m = p.start();822	if p.at(T![?]) {823		p.bump();824		m.complete(p, DESTRUCT_SKIP)825	} else if p.at(T!['[']) {826		p.bump();827		let mut had_rest = false;828		loop {829			if p.at(T![']']) {830				p.bump();831				break;832			} else if p.at(T![...]) {833				let m_err = p.start_ranger();834				destruct_rest(p);835				if had_rest {836					p.custom_error(m_err.finish(p), "only one rest can be present in array");837				}838				had_rest = true;839			} else {840				destruct(p);841			}842			if p.at(T![,]) {843				p.bump();844				continue;845			}846			p.expect(T![']']);847			break;848		}849		m.complete(p, DESTRUCT_ARRAY)850	} else if p.at(T!['{']) {851		p.bump();852		let mut had_rest = false;853		loop {854			if p.at(T!['}']) {855				p.bump();856				break;857			} else if p.at(T![...]) {858				let m_err = p.start_ranger();859				destruct_rest(p);860				if had_rest {861					p.custom_error(m_err.finish(p), "only one rest can be present in object");862				}863				had_rest = true;864			} else {865				if had_rest {866					p.error_with_recovery_set(TS![]);867				}868				destruct_object_field(p);869			}870			if p.at(T![,]) {871				p.bump();872				continue;873			}874			p.expect(T!['}']);875			break;876		}877		m.complete(p, DESTRUCT_OBJECT)878	} else if p.at(IDENT) {879		name(p);880		m.complete(p, DESTRUCT_FULL)881	} else {882		m.complete(p, ERROR)883	}884}885fn bind(p: &mut Parser) {886	let m = p.start();887	if p.at(IDENT) && p.nth_at(1, T!['(']) {888		name(p);889		params_desc(p);890		p.expect(T![=]);891		expr(p);892		m.complete(p, BIND_FUNCTION)893	} else {894		destruct(p);895		p.expect(T![=]);896		expr(p);897		m.complete(p, BIND_DESTRUCT)898	};899}900fn text(p: &mut Parser) {901	assert!(Text::can_cast(p.current()));902	p.bump();903}904fn number(p: &mut Parser) {905	assert!(Number::can_cast(p.current()));906	p.bump();907}908fn literal(p: &mut Parser) {909	assert!(Literal::can_cast(p.current()));910	p.bump();911}912fn lhs_basic(p: &mut Parser) -> Option<CompletedMarker> {913	let _e = p.expected_syntax_name("value");914	Some(if Literal::can_cast(p.current()) {915		let m = p.start();916		literal(p);917		m.complete(p, EXPR_LITERAL)918	} else if Text::can_cast(p.current()) {919		let m = p.start();920		text(p);921		m.complete(p, EXPR_STRING)922	} else if Number::can_cast(p.current()) {923		let m = p.start();924		number(p);925		m.complete(p, EXPR_NUMBER)926	} else if p.at(IDENT) {927		let m = p.start();928		name(p);929		m.complete(p, EXPR_VAR)930	} else if p.at(INTRINSIC_THIS_FILE) {931		let m = p.start();932		p.bump();933		m.complete(p, EXPR_INTRINSIC_THIS_FILE)934	} else if p.at(INTRINSIC_ID) {935		let m = p.start();936		p.bump();937		m.complete(p, EXPR_INTRINSIC_ID)938	} else if p.at(INTRINSIC) {939		let m = p.start();940		p.bump();941		p.expect(T!['(']);942		name(p);943		p.expect(T![')']);944		m.complete(p, EXPR_INTRINSIC)945	} else if p.at(T![if]) {946		let m = p.start();947		p.bump();948		expr(p);949		p.expect(T![then]);950		expr(p).map(|c| c.wrap(p, TRUE_EXPR));951		if p.at(T![else]) {952			p.bump();953			expr(p).map(|c| c.wrap(p, FALSE_EXPR));954		}955		m.complete(p, EXPR_IF_THEN_ELSE)956	} else if p.at(T!['[']) {957		array(p)958	} else if p.at(T!['{']) {959		object(p)960	} else if p.at(T![local]) {961		let m = p.start();962		p.bump();963		loop {964			if p.at(T![;]) {965				p.bump();966				break;967			}968			bind(p);969970			if p.at(T![,]) {971				p.bump();972				continue;973			}974			p.expect(T![;]);975			break;976		}977		expr(p);978		m.complete(p, EXPR_LOCAL)979	} else if p.at(T![function]) {980		let m = p.start();981		p.bump();982		params_desc(p);983		expr(p);984		m.complete(p, EXPR_FUNCTION)985	} else if p.at(T![error]) {986		let m = p.start();987		p.bump();988		expr(p);989		m.complete(p, EXPR_ERROR)990	} else if p.at(T![assert]) {991		let m = p.start();992		assertion(p);993		p.expect(T![;]);994		expr(p);995		m.complete(p, EXPR_ASSERT)996	} else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {997		let m = p.start();998		p.bump();999		text(p);1000		m.complete(p, EXPR_IMPORT)1001	} else if p.at(T![-]) || p.at(T![!]) || p.at(T![~]) {1002		let op = match p.current() {1003			T![-] => UnaryOperator::Minus,1004			T![!] => UnaryOperator::Not,1005			T![~] => UnaryOperator::BitNegate,1006			_ => unreachable!(),1007		};1008		let ((), right_binding_power) = op.binding_power();10091010		let m = p.start();1011		p.bump();1012		expr_binding_power(p, right_binding_power);1013		m.complete(p, EXPR_UNARY)1014	} else if p.at(T!['(']) {1015		let m = p.start();1016		p.bump();1017		expr(p);1018		p.expect(T![')']);1019		m.complete(p, EXPR_PARENED)1020	} else {1021		p.error_with_recovery_set(TS![]);1022		return None;1023	})1024}10251026impl Parse {1027	pub fn syntax(&self) -> SyntaxNode {1028		SyntaxNode::new_root(self.green_node.clone())1029	}1030}