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

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	string_block::{lex_str_block, StringBlockError},12	token_set::SyntaxKindSet,13	unary::UnaryOperator,14	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	lexemes: &'i [Lexeme<'i>],40	pub offset: usize,41	pub events: Vec<Event>,42	pub entered: u32,43	pub hints: Vec<(u32, TextRange, String)>,44	pub last_error_token: usize,45	expected_syntax: Option<ExpectedSyntax>,46	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,47	steps: Cell<u64>,48}4950const DEFAULT_RECOVERY_SET: SyntaxKindSet = TS![];5152#[derive(Clone, Debug, PartialEq, Eq)]53pub enum SyntaxError {54	Unexpected {55		expected: ExpectedSyntax,56		found: SyntaxKind,57		range: TextRange,58	},59	Missing {60		expected: ExpectedSyntax,61		offset: TextSize,62	},63	Custom {64		error: String,65		range: TextRange,66	},67	Hint {68		error: String,69		range: TextRange,70	},71}7273impl From<SyntaxError> for LabeledSpan {74	fn from(val: SyntaxError) -> Self {75		match val {76			SyntaxError::Unexpected {77				expected,78				found,79				range,80			} => LabeledSpan::new_with_span(81				Some(format!("expected {}, found {:?}", expected, found)),82				SourceSpan::new(83					SourceOffset::from(usize::from(range.start())),84					SourceOffset::from(usize::from(range.end() - range.start())),85				),86			),87			SyntaxError::Missing { expected, offset } => LabeledSpan::new_with_span(88				Some(format!("missing {}", expected)),89				SourceSpan::new(90					SourceOffset::from(usize::from(offset)),91					SourceOffset::from(0),92				),93			),94			SyntaxError::Custom { error, range } | SyntaxError::Hint { error, range } => {95				LabeledSpan::new_with_span(96					Some(error),97					SourceSpan::new(98						SourceOffset::from(usize::from(range.start())),99						SourceOffset::from(usize::from(range.end() - range.start())),100					),101				)102			}103		}104	}105}106107impl<'i> Parser<'i> {108	pub fn new(lexemes: &'i [Lexeme<'i>]) -> Self {109		Self {110			lexemes,111			offset: 0,112			events: vec![],113			entered: 0,114			last_error_token: 0,115			hints: vec![],116			expected_syntax: None,117			expected_syntax_tracking_state: Rc::new(Cell::new(118				ExpectedSyntaxTrackingState::Unnamed,119			)),120			steps: Cell::new(0),121		}122	}123	pub fn clear_outdated_hints(&mut self) {124		let amount = self125			.hints126			.iter()127			.rev()128			.take_while(|h| h.0 > self.entered)129			.count();130		self.hints.truncate(self.hints.len() - amount)131	}132	fn clear_expected_syntaxes(&mut self) {133		self.expected_syntax = None;134		self.expected_syntax_tracking_state135			.set(ExpectedSyntaxTrackingState::Unnamed);136	}137	pub fn start(&mut self) -> Marker {138		self.skip_trivia();139		let start_event_idx = self.events.len();140		self.events.push(Event::Pending);141		self.entered += 1;142		Marker::new(start_event_idx)143	}144	pub fn start_ranger(&mut self) -> Ranger {145		self.skip_trivia();146		let pos = self.offset;147		Ranger { pos }148	}149	pub fn parse(mut self) -> Vec<Event> {150		let m = self.start();151		expr(&mut self);152		self.expect(EOF);153		m.complete(&mut self, SOURCE_FILE);154155		self.events156	}157158	pub(crate) fn expect(&mut self, kind: SyntaxKind) {159		self.expect_with_recovery_set(kind, TS![])160	}161162	pub(crate) fn expect_with_recovery_set(163		&mut self,164		kind: SyntaxKind,165		recovery_set: SyntaxKindSet,166	) {167		if self.at(kind) {168			if kind != EOF {169				self.bump();170			}171		} else {172			self.error_with_recovery_set(recovery_set);173		}174	}175176	pub(crate) fn expect_with_no_skip(&mut self, kind: SyntaxKind) {177		if self.at(kind) {178			self.bump();179		} else {180			self.error_with_no_skip();181		}182	}183	fn current_token(&self) -> Lexeme<'i> {184		self.lexemes[self.offset]185	}186	fn previous_token(&mut self) -> Option<Lexeme<'i>> {187		if self.offset == 0 {188			return None;189		}190		let mut previous_token_idx = self.offset - 1;191		while self192			.lexemes193			.get(previous_token_idx)194			.map_or(false, |l| l.kind.is_trivia())195			&& previous_token_idx != 0196		{197			previous_token_idx -= 1;198		}199200		Some(self.lexemes[previous_token_idx])201	}202	pub fn start_of_token(&self, mut idx: usize) -> TextSize {203		while self.lexemes[idx].kind.is_trivia() {204			idx += 1;205		}206		self.lexemes[idx].range.start()207	}208	pub fn end_of_token(&self, mut idx: usize) -> TextSize {209		while self.lexemes[idx].kind.is_trivia() {210			idx -= 1;211		}212		self.lexemes[idx].range.end()213	}214	pub(crate) fn custom_error(&mut self, marker: impl AsRange, error: impl AsRef<str>) {215		self.last_error_token = marker.end_token();216		self.events.push(Event::Error(SyntaxError::Custom {217			error: error.as_ref().to_string(),218			range: marker.as_range(self),219		}));220	}221	pub(crate) fn error_with_recovery_set(222		&mut self,223		recovery_set: SyntaxKindSet,224	) -> Option<CompletedMarker> {225		self.error_with_recovery_set_no_default(recovery_set.union(DEFAULT_RECOVERY_SET))226	}227	pub fn error_with_no_skip(&mut self) -> Option<CompletedMarker> {228		self.error_with_recovery_set_no_default(SyntaxKindSet::ALL)229	}230231	pub fn error_with_recovery_set_no_default(232		&mut self,233		recovery_set: SyntaxKindSet,234	) -> Option<CompletedMarker> {235		let expected_syntax = self236			.expected_syntax237			.take()238			.unwrap_or(ExpectedSyntax::Named("unknown"));239		self.expected_syntax_tracking_state240			.set(ExpectedSyntaxTrackingState::Unnamed);241242		self.skip_trivia();243		if self.at_end() || self.at_ts(recovery_set) {244			let range = self245				.previous_token()246				.map(|t| t.range)247				.unwrap_or_else(|| TextRange::at(TextSize::from(0), TextSize::from(0)));248249			self.events.push(Event::Error(SyntaxError::Missing {250				expected: expected_syntax,251				offset: range.end(),252			}));253			return None;254		}255256		let current_token = self.current_token();257258		self.events.push(Event::Error(SyntaxError::Unexpected {259			expected: expected_syntax,260			found: current_token.kind,261			range: current_token.range,262		}));263		self.clear_expected_syntaxes();264		self.last_error_token = self.offset;265266		let m = self.start();267		self.bump();268		Some(m.complete(self, SyntaxKind::ERROR))269	}270271	fn bump(&mut self) {272		self.skip_trivia();273		self.bump_remap(self.current());274	}275	fn bump_remap(&mut self, kind: SyntaxKind) {276		self.skip_trivia();277		assert_ne!(self.offset, self.lexemes.len(), "already at end");278		self.events.push(Event::Token { kind });279		self.offset += 1;280		self.clear_expected_syntaxes();281	}282	fn step(&self) {283		use std::fmt::Write;284		let steps = self.steps.get();285		if steps >= 15000000 {286			let mut out = "seems like parsing is stuck".to_owned();287			{288				let last = 20;289				write!(out, "\n\nLast {} events:", last).unwrap();290				for (i, event) in self291					.events292					.iter()293					.skip(self.events.len().saturating_sub(last))294					.enumerate()295				{296					write!(out, "\n{i}. {event:?}").unwrap();297				}298			}299			{300				let next = 20;301				write!(out, "\n\nNext {next} tokens:").unwrap();302				for (i, tok) in self.lexemes.iter().skip(self.offset).take(next).enumerate() {303					write!(out, "\n{i}. {tok:?}").unwrap();304				}305			}306			panic!("{out}")307		}308		self.steps.set(steps + 1);309	}310	fn nth(&self, i: usize) -> SyntaxKind {311		self.step();312		let mut offset = self.offset;313		for _ in 0..i {314			while self315				.lexemes316				.get(offset)317				.map(|l| l.kind.is_trivia())318				.unwrap_or(false)319			{320				offset += 1;321			}322			offset += 1;323		}324		while self325			.lexemes326			.get(offset)327			.map(|l| l.kind.is_trivia())328			.unwrap_or(false)329		{330			offset += 1;331		}332		self.lexemes.get(offset).map(|l| l.kind).unwrap_or(EOF)333	}334	fn current(&self) -> SyntaxKind {335		self.nth(0)336	}337	fn skip_trivia(&mut self) {338		while self.peek_raw().is_trivia() {339			self.offset += 1;340		}341	}342	fn current_lexeme(&mut self) -> Option<&Lexeme> {343		self.skip_trivia();344		self.lexemes.get(self.offset)345	}346	fn peek_raw(&mut self) -> SyntaxKind {347		self.lexemes348			.get(self.offset)349			.map(|l| l.kind)350			.unwrap_or(SyntaxKind::EOF)351	}352	#[must_use]353	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {354		self.expected_syntax_tracking_state355			.set(ExpectedSyntaxTrackingState::Named);356		self.expected_syntax = Some(ExpectedSyntax::Named(name));357358		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))359	}360	pub fn at(&mut self, kind: SyntaxKind) -> bool {361		self.nth_at(0, kind)362	}363	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {364		if let ExpectedSyntaxTrackingState::Unnamed = self.expected_syntax_tracking_state.get() {365			self.expected_syntax = Some(ExpectedSyntax::Unnamed(kind));366		}367		self.nth(n) == kind368	}369	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {370		set.contains(self.current())371	}372	pub fn at_end(&mut self) -> bool {373		self.at(EOF)374	}375}376pub(crate) struct ExpectedSyntaxGuard {377	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,378}379380impl ExpectedSyntaxGuard {381	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>) -> Self {382		Self {383			expected_syntax_tracking_state,384		}385	}386}387388impl Drop for ExpectedSyntaxGuard {389	fn drop(&mut self) {390		self.expected_syntax_tracking_state391			.set(ExpectedSyntaxTrackingState::Unnamed);392	}393}394395#[derive(Debug, Clone, Copy)]396enum ExpectedSyntaxTrackingState {397	Named,398	Unnamed,399}400macro_rules! at_match {401	($p:ident {402		$($r:expr => $e:expr,)*403		_ => $else:expr $(,)?404	}) => {{405		$(406			if $p.at($r) {$e} else407		)* {408			$else409		}410	}}411}412413fn expr(p: &mut Parser) -> Option<CompletedMarker> {414	expr_binding_power(p, 0)415}416fn expr_binding_power(p: &mut Parser, minimum_binding_power: u8) -> Option<CompletedMarker> {417	let mut lhs = lhs(p)?;418419	loop {420		let op = at_match!(p {421			T![*] => BinaryOperator::Mul,422			T![/] => BinaryOperator::Div,423			T![%] => BinaryOperator::Mod,424			T![+] => BinaryOperator::Plus,425			T![-] => BinaryOperator::Minus,426			T![<<] => BinaryOperator::ShiftLeft,427			T![>>] => BinaryOperator::ShiftRight,428			T![<] => BinaryOperator::LessThan,429			T![>] => BinaryOperator::GreaterThan,430			T![<=] => BinaryOperator::LessThanOrEqual,431			T![>=] => BinaryOperator::GreaterThanOrEqual,432			T![==] => BinaryOperator::Equal,433			T![!=] => BinaryOperator::NotEqual,434			T![&] => BinaryOperator::BitAnd,435			T![^] => BinaryOperator::BitXor,436			T![|] => BinaryOperator::BitOr,437			T![&&] => BinaryOperator::And,438			T![||] => BinaryOperator::Or,439			T![in] => BinaryOperator::In,440			T!['{'] => BinaryOperator::ObjectApply,441			_ => break,442		});443		let (left_binding_power, right_binding_power) = op.binding_power();444		if left_binding_power < minimum_binding_power {445			break;446		}447448		// Object apply is not a real operator, we dont have something to bump449		if op != BinaryOperator::ObjectApply {450			p.bump();451		}452453		let m = lhs.wrap(p, LHS_EXPR).precede(p);454		let parsed_rhs = expr_binding_power(p, right_binding_power).is_some();455		lhs = m.complete(456			p,457			if op == BinaryOperator::ObjectApply {458				EXPR_OBJ_EXTEND459			} else {460				EXPR_BINARY461			},462		);463464		if !parsed_rhs {465			break;466		}467	}468	Some(lhs)469}470fn compspec(p: &mut Parser) {471	assert!(p.at(T![for]) || p.at(T![if]));472	if p.at(T![for]) {473		let m = p.start();474		p.bump();475		name(p);476		p.expect(T![in]);477		expr(p);478		m.complete(p, FOR_SPEC);479	} else if p.at(T![if]) {480		let m = p.start();481		p.bump();482		expr(p);483		m.complete(p, IF_SPEC);484	} else {485		unreachable!()486	}487}488fn comma(p: &mut Parser) -> bool {489	if p.at(T![,]) {490		p.bump();491		true492	} else {493		false494	}495}496fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {497	if p.at(T![,]) {498		p.bump();499		true500	} else if p.at_ts(set) {501		p.expect_with_no_skip(T![,]);502		p.bump();503		true504	} else {505		false506	}507}508fn field_name(p: &mut Parser) {509	let _e = p.expected_syntax_name("field name");510	let m = p.start();511	if p.at(T!['[']) {512		p.bump();513		expr(p);514		p.expect(T![']']);515		m.complete(p, FIELD_NAME_DYNAMIC);516	} else if p.at(IDENT) {517		name(p);518		m.complete(p, FIELD_NAME_FIXED);519	} else if p.current().is_string() {520		string(p);521		m.complete(p, FIELD_NAME_FIXED);522	} else {523		p.error_with_recovery_set(TS![;]);524	}525}526fn visibility(p: &mut Parser) {527	if p.at_ts(TS![: :: :::]) {528		p.bump()529	} else {530		p.error_with_recovery_set(TS![]);531	}532}533fn field(p: &mut Parser) {534	let m = p.start();535	field_name(p);536	let plus = if p.at(T![+]) {537		let r = p.start_ranger();538		p.bump();539		Some(r.finish(p))540	} else {541		None542	};543	let params = if p.at(T!['(']) {544		if let Some(plus) = plus {545			p.custom_error(plus, "can't extend with method");546		}547		params_desc(p);548		if p.at(T![+]) {549			let r = p.start_ranger();550			p.bump();551			p.custom_error(r.finish(p), "can't extend with method");552		}553		true554	} else {555		false556	};557	visibility(p);558	expr(p);559560	if params {561		m.complete(p, FIELD_METHOD)562	} else {563		m.complete(p, FIELD_NORMAL)564	};565}566fn assertion(p: &mut Parser) {567	assert!(p.at(T![assert]));568	let m = p.start();569	p.bump();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	assert!(p.at(T!['{']));579	let m_t = p.start();580	let m = p.start();581	p.bump();582583	loop {584		if p.at(T!['}']) {585			p.bump();586			break;587		}588		let m = p.start();589		if p.at(T![local]) {590			obj_local(p);591			m.complete(p, MEMBER_BIND_STMT)592		} else if p.at(T![assert]) {593			assertion(p);594			m.complete(p, MEMBER_ASSERT_STMT)595		} else {596			field(p);597			while p.at(T![for]) || p.at(T![if]) {598				compspec(p)599			}600			m.complete(p, MEMBER_FIELD)601		};602		if comma_with_alternatives(p, SyntaxKindSet::new(&[T![=]])) {603			continue;604		}605		p.expect(R_BRACE);606		break;607	}608609	m.complete(p, OBJ_BODY_MEMBER_LIST);610	m_t.complete(p, EXPR_OBJECT)611}612fn param(p: &mut Parser) {613	let m = p.start();614	destruct(p);615	if p.at(T![=]) {616		p.bump();617		expr(p);618	}619	m.complete(p, PARAM);620}621fn params_desc(p: &mut Parser) -> CompletedMarker {622	assert!(p.at(T!['(']));623	let m = p.start();624	p.bump();625626	loop {627		if p.at(T![')']) {628			p.bump();629			break;630		}631		param(p);632		if comma(p) {633			continue;634		}635		p.expect(T![')']);636		break;637	}638639	m.complete(p, PARAMS_DESC)640}641fn args_desc(p: &mut Parser) {642	let m = p.start();643	assert!(p.at(T!['(']));644	p.bump();645646	let started_named = Cell::new(false);647648	loop {649		if p.at(T![')']) {650			break;651		}652653		let m = p.start();654		if p.at(IDENT) && p.nth_at(1, T![=]) {655			name(p);656			p.bump();657			expr(p);658			m.complete(p, ARG);659			started_named.set(true);660		} else {661			expr(p);662			m.complete(p, ARG);663		}664		if comma(p) {665			continue;666		}667		break;668	}669	p.expect(T![')']);670	if p.at(T![tailstrict]) {671		p.bump()672	}673	m.complete(p, ARGS_DESC);674}675676fn array(p: &mut Parser) -> CompletedMarker {677	assert!(p.at(T!['[']));678	// Start the list node679	let m = p.start();680	p.bump(); // '['681682	// This vec will have at most one element in case of correct input683	let mut compspecs = Vec::with_capacity(1);684	let mut elems = 0;685686	loop {687		if p.at(T![']']) {688			p.bump();689			break;690		}691		elems += 1;692		expr(p);693		let c = p.start_ranger();694		let mut had_spec = false;695		while p.at(T![for]) || p.at(T![if]) {696			had_spec = true;697			compspec(p)698		}699		if had_spec {700			compspecs.push(c.finish(p));701		}702		if comma(p) {703			continue;704		}705		p.expect(T![']']);706		break;707	}708709	if elems > 1 && !compspecs.is_empty() {710		for spec in compspecs {711			p.custom_error(712				spec,713				"compspec may only be used if there is only one array element",714			)715		}716717		m.complete(p, EXPR_ARRAY)718	} else if !compspecs.is_empty() {719		m.complete(p, EXPR_ARRAY_COMP)720	} else {721		m.complete(p, EXPR_ARRAY)722	}723}724/// Returns true if it was slice, false if just index725#[must_use]726fn slice_desc_or_index(p: &mut Parser) -> bool {727	let m = p.start();728	p.bump();729	// TODO: do not treat :, ::, ::: as full tokens?730	// Start731	if !p.at(T![:]) && !p.at(T![::]) {732		expr(p);733	}734	if p.at(T![:]) {735		p.bump();736		// End737		if !p.at(T![']']) {738			expr(p).map(|c| c.wrap(p, SLICE_DESC_END));739		}740		if p.at(T![:]) {741			p.bump();742			// Step743			if !p.at(T![']']) {744				expr(p).map(|c| c.wrap(p, SLICE_DESC_STEP));745			}746		}747	} else if p.at(T![::]) {748		p.bump();749		// End750		if !p.at(T![']']) {751			expr(p).map(|c| c.wrap(p, SLICE_DESC_END));752		}753	} else {754		// It was not a slice755		p.expect(T![']']);756		m.forget(p);757		return false;758	}759	p.expect(T![']']);760	m.complete(p, SLICE_DESC);761	true762}763fn lhs(p: &mut Parser) -> Option<CompletedMarker> {764	let mut lhs = lhs_basic(p)?;765766	loop {767		if p.at(T![.]) {768			let m = lhs.precede(p);769			p.bump();770			name(p);771			lhs = m.complete(p, EXPR_INDEX);772		} else if p.at(T!['[']) {773			if slice_desc_or_index(p) {774				lhs = lhs.precede(p).complete(p, EXPR_SLICE);775			} else {776				lhs = lhs777					.wrap(p, LHS_EXPR)778					.precede(p)779					.complete(p, EXPR_INDEX_EXPR);780			}781		} else if p.at(T!['(']) {782			let m = lhs.precede(p);783			args_desc(p);784			lhs = m.complete(p, EXPR_APPLY);785		} else {786			break;787		}788	}789790	Some(lhs)791}792fn name(p: &mut Parser) {793	let m = p.start();794	p.expect(IDENT);795	m.complete(p, NAME);796}797fn destruct_rest(p: &mut Parser) {798	assert!(p.at(T![...]));799	p.bump();800	let m = p.start();801	if p.at(IDENT) {802		p.bump()803	}804	m.complete(p, DESTRUCT_REST);805}806fn destruct_object_field(p: &mut Parser) {807	let m = p.start();808	name(p);809	if p.at(T![:]) {810		p.bump();811		destruct(p);812	};813	if p.at(T![=]) {814		p.bump();815		expr(p);816	}817	m.complete(p, DESTRUCT_OBJECT_FIELD);818}819fn obj_local(p: &mut Parser) {820	assert!(p.at(T![local]));821	let m = p.start();822	p.bump();823	bind(p);824	m.complete(p, OBJ_LOCAL);825}826fn destruct(p: &mut Parser) -> CompletedMarker {827	let m = p.start();828	if p.at(T![?]) {829		p.bump();830		m.complete(p, DESTRUCT_SKIP)831	} else if p.at(T!['[']) {832		p.bump();833		let mut had_rest = false;834		loop {835			if p.at(T![']']) {836				p.bump();837				break;838			} else if p.at(T![...]) {839				let m_err = p.start_ranger();840				destruct_rest(p);841				if had_rest {842					p.custom_error(m_err.finish(p), "only one rest can be present in array");843				}844				had_rest = true;845			} else {846				destruct(p);847			}848			if p.at(T![,]) {849				p.bump();850				continue;851			}852			p.expect(T![']']);853			break;854		}855		m.complete(p, DESTRUCT_ARRAY)856	} else if p.at(T!['{']) {857		p.bump();858		let mut had_rest = false;859		loop {860			if p.at(T!['}']) {861				p.bump();862				break;863			} else if p.at(T![...]) {864				let m_err = p.start_ranger();865				destruct_rest(p);866				if had_rest {867					p.custom_error(m_err.finish(p), "only one rest can be present in object");868				}869				had_rest = true;870			} else {871				if had_rest {872					p.error_with_recovery_set(TS![]);873				}874				destruct_object_field(p);875			}876			if p.at(T![,]) {877				p.bump();878				continue;879			}880			p.expect(T!['}']);881			break;882		}883		m.complete(p, DESTRUCT_OBJECT)884	} else if p.at(IDENT) {885		name(p);886		m.complete(p, DESTRUCT_FULL)887	} else {888		m.complete(p, ERROR)889	}890}891fn bind(p: &mut Parser) {892	let m = p.start();893	if p.at(IDENT) && p.nth_at(1, T!['(']) {894		name(p);895		params_desc(p);896		p.expect(T![=]);897		expr(p);898		m.complete(p, BIND_FUNCTION)899	} else {900		destruct(p);901		p.expect(T![=]);902		expr(p);903		m.complete(p, BIND_DESTRUCT)904	};905}906fn string(p: &mut Parser) {907	assert!(p.current().is_string());908	if p.at(STRING_BLOCK) {909		// We use custom lexer, which skips enough bytes, but not returns error910		// Instead we should call lexer again to verify if there is something wrong with string block911		let mut lexer = logos::Lexer::<SyntaxKind>::new(dbg!(912			&p.current_lexeme().expect("parser is at string block").text913		));914		// In kinds, string blocks is parsed at least as `|||`915		lexer.bump(3);916		let res = lex_str_block(&mut lexer);917		debug_assert!(lexer.next().is_none(), "str_block is lexed");918		match res {919			Ok(_) => {920				p.bump();921			}922			Err(e) => p.bump_remap(match e {923				StringBlockError::UnexpectedEnd => ERROR_STRING_BLOCK_UNEXPECTED_END,924				StringBlockError::MissingNewLine => ERROR_STRING_BLOCK_MISSING_NEW_LINE,925				StringBlockError::MissingTermination => ERROR_STRING_BLOCK_MISSING_TERMINATION,926				StringBlockError::MissingIndent => ERROR_STRING_BLOCK_MISSING_INDENT,927			}),928		}929	} else {930		p.bump();931	}932}933fn number(p: &mut Parser) {934	assert!(p.current().is_number());935	p.bump();936}937fn literal(p: &mut Parser) {938	assert!(p.current().is_literal());939	p.bump();940}941fn lhs_basic(p: &mut Parser) -> Option<CompletedMarker> {942	let _e = p.expected_syntax_name("value");943	Some(if p.current().is_literal() {944		let m = p.start();945		literal(p);946		m.complete(p, EXPR_LITERAL)947	} else if p.current().is_string() {948		let m = p.start();949		string(p);950		m.complete(p, EXPR_STRING)951	} else if p.current().is_number() {952		let m = p.start();953		number(p);954		m.complete(p, EXPR_NUMBER)955	} else if p.at(IDENT) {956		let m = p.start();957		name(p);958		m.complete(p, EXPR_VAR)959	} else if p.at(INTRINSIC_THIS_FILE) {960		let m = p.start();961		p.bump();962		m.complete(p, EXPR_INTRINSIC_THIS_FILE)963	} else if p.at(INTRINSIC_ID) {964		let m = p.start();965		p.bump();966		m.complete(p, EXPR_INTRINSIC_ID)967	} else if p.at(INTRINSIC) {968		let m = p.start();969		p.bump();970		p.expect(T!['(']);971		name(p);972		p.expect(T![')']);973		m.complete(p, EXPR_INTRINSIC)974	} else if p.at(T![if]) {975		let m = p.start();976		p.bump();977		expr(p);978		p.expect(T![then]);979		expr(p).map(|c| c.wrap(p, TRUE_EXPR));980		if p.at(T![else]) {981			p.bump();982			expr(p).map(|c| c.wrap(p, FALSE_EXPR));983		}984		m.complete(p, EXPR_IF_THEN_ELSE)985	} else if p.at(T!['[']) {986		array(p)987	} else if p.at(T!['{']) {988		object(p)989	} else if p.at(T![local]) {990		let m = p.start();991		p.bump();992		loop {993			if p.at(T![;]) {994				p.bump();995				break;996			}997			bind(p);998999			if p.at(T![,]) {1000				p.bump();1001				continue;1002			}1003			p.expect(T![;]);1004			break;1005		}1006		expr(p);1007		m.complete(p, EXPR_LOCAL)1008	} else if p.at(T![function]) {1009		let m = p.start();1010		p.bump();1011		params_desc(p);1012		expr(p);1013		m.complete(p, EXPR_FUNCTION)1014	} else if p.at(T![error]) {1015		let m = p.start();1016		p.bump();1017		expr(p);1018		m.complete(p, EXPR_ERROR)1019	} else if p.at(T![assert]) {1020		let m = p.start();1021		assertion(p);1022		p.expect(T![;]);1023		expr(p);1024		m.complete(p, EXPR_ASSERT)1025	} else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {1026		let m = p.start();1027		p.bump();1028		string(p);1029		m.complete(p, EXPR_IMPORT)1030	} else if p.at(T![-]) || p.at(T![!]) || p.at(T![~]) {1031		let op = match p.current() {1032			T![-] => UnaryOperator::Minus,1033			T![!] => UnaryOperator::Not,1034			T![~] => UnaryOperator::BitNegate,1035			_ => unreachable!(),1036		};1037		let ((), right_binding_power) = op.binding_power();10381039		let m = p.start();1040		p.bump();1041		expr_binding_power(p, right_binding_power);1042		m.complete(p, EXPR_UNARY)1043	} else if p.at(T!['(']) {1044		let m = p.start();1045		p.bump();1046		expr(p);1047		assert!(p.at(T![')']));1048		p.bump();1049		m.complete(p, EXPR_PARENED)1050	} else {1051		p.error_with_recovery_set(TS![]);1052		return None;1053	})1054}10551056impl Parse {1057	pub fn syntax(&self) -> SyntaxNode {1058		SyntaxNode::new_root(self.green_node.clone())1059	}1060}