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	event::Event,8	lex::Lexeme,9	marker::{AsRange, CompletedMarker, Marker, Ranger},10	nodes::{BinaryOperatorKind, Literal, Number, Text, Trivia, UnaryOperatorKind},11	token_set::SyntaxKindSet,12	AstToken, SyntaxKind,13	SyntaxKind::*,14	SyntaxNode, T, TS,15};1617pub struct Parse {18	pub green_node: GreenNode,19	pub errors: Vec<SyntaxError>,20}2122#[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}3536pub struct Parser<'i> {37	// TODO: remove all trivia before feeding to parser?38	lexemes: &'i [Lexeme<'i>],39	pub offset: usize,40	pub events: Vec<Event>,41	pub entered: u32,42	pub hints: Vec<(u32, TextRange, String)>,43	pub last_error_token: usize,44	expected_syntax: Option<ExpectedSyntax>,45	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,46	steps: Cell<u64>,47}4849const DEFAULT_RECOVERY_SET: SyntaxKindSet = TS![];5051#[derive(Clone, Debug, PartialEq, Eq)]52pub enum SyntaxError {53	Unexpected {54		expected: ExpectedSyntax,55		found: SyntaxKind,56		range: TextRange,57	},58	Missing {59		expected: ExpectedSyntax,60		offset: TextSize,61	},62	Custom {63		error: String,64		range: TextRange,65	},66	Hint {67		error: String,68		range: TextRange,69	},70}7172impl From<SyntaxError> for LabeledSpan {73	fn from(val: SyntaxError) -> Self {74		match val {75			SyntaxError::Unexpected {76				expected,77				found,78				range,79			} => LabeledSpan::new_with_span(80				Some(format!("expected {}, found {:?}", expected, found)),81				SourceSpan::new(82					SourceOffset::from(usize::from(range.start())),83					SourceOffset::from(usize::from(range.end() - range.start())),84				),85			),86			SyntaxError::Missing { expected, offset } => LabeledSpan::new_with_span(87				Some(format!("missing {}", expected)),88				SourceSpan::new(89					SourceOffset::from(usize::from(offset)),90					SourceOffset::from(0),91				),92			),93			SyntaxError::Custom { error, range } | SyntaxError::Hint { error, range } => {94				LabeledSpan::new_with_span(95					Some(error),96					SourceSpan::new(97						SourceOffset::from(usize::from(range.start())),98						SourceOffset::from(usize::from(range.end() - range.start())),99					),100				)101			}102		}103	}104}105106impl<'i> Parser<'i> {107	pub fn new(lexemes: &'i [Lexeme<'i>]) -> Self {108		Self {109			lexemes,110			offset: 0,111			events: vec![],112			entered: 0,113			last_error_token: 0,114			hints: vec![],115			expected_syntax: None,116			expected_syntax_tracking_state: Rc::new(Cell::new(117				ExpectedSyntaxTrackingState::Unnamed,118			)),119			steps: Cell::new(0),120		}121	}122	pub fn clear_outdated_hints(&mut self) {123		let amount = self124			.hints125			.iter()126			.rev()127			.take_while(|h| h.0 > self.entered)128			.count();129		self.hints.truncate(self.hints.len() - amount)130	}131	fn clear_expected_syntaxes(&mut self) {132		self.expected_syntax = None;133		self.expected_syntax_tracking_state134			.set(ExpectedSyntaxTrackingState::Unnamed);135	}136	pub fn start(&mut self) -> Marker {137		self.skip_trivia();138		let start_event_idx = self.events.len();139		self.events.push(Event::Pending);140		self.entered += 1;141		Marker::new(start_event_idx)142	}143	pub fn start_ranger(&mut self) -> Ranger {144		self.skip_trivia();145		let pos = self.offset;146		Ranger { pos }147	}148	pub fn parse(mut self) -> Vec<Event> {149		let m = self.start();150		expr(&mut self);151		self.expect(EOF);152		m.complete(&mut self, SOURCE_FILE);153154		self.events155	}156157	pub(crate) fn expect(&mut self, kind: SyntaxKind) {158		self.expect_with_recovery_set(kind, TS![])159	}160161	pub(crate) fn expect_with_recovery_set(162		&mut self,163		kind: SyntaxKind,164		recovery_set: SyntaxKindSet,165	) {166		if self.at(kind) {167			if kind != EOF {168				self.bump();169			}170		} else {171			self.error_with_recovery_set(recovery_set);172		}173	}174175	pub(crate) fn expect_with_no_skip(&mut self, kind: SyntaxKind) {176		if self.at(kind) {177			self.bump();178		} else {179			self.error_with_no_skip();180		}181	}182	fn current_token(&self) -> Lexeme<'i> {183		self.lexemes[self.offset]184	}185	fn previous_token(&mut self) -> Option<Lexeme<'i>> {186		if self.offset == 0 {187			return None;188		}189		let mut previous_token_idx = self.offset - 1;190		while self191			.lexemes192			.get(previous_token_idx)193			.map_or(false, |l| Trivia::can_cast(l.kind))194			&& previous_token_idx != 0195		{196			previous_token_idx -= 1;197		}198199		Some(self.lexemes[previous_token_idx])200	}201	pub fn start_of_token(&self, mut idx: usize) -> TextSize {202		while Trivia::can_cast(self.lexemes[idx].kind) {203			idx += 1;204		}205		self.lexemes[idx].range.start()206	}207	pub fn end_of_token(&self, mut idx: usize) -> TextSize {208		while Trivia::can_cast(self.lexemes[idx].kind) {209			idx -= 1;210		}211		self.lexemes[idx].range.end()212	}213	pub(crate) fn custom_error(&mut self, marker: impl AsRange, error: impl AsRef<str>) {214		self.last_error_token = marker.end_token();215		self.events.push(Event::Error(SyntaxError::Custom {216			error: error.as_ref().to_string(),217			range: marker.as_range(self),218		}));219	}220	pub(crate) fn error_with_recovery_set(221		&mut self,222		recovery_set: SyntaxKindSet,223	) -> Option<CompletedMarker> {224		self.error_with_recovery_set_no_default(recovery_set.union(DEFAULT_RECOVERY_SET))225	}226	pub fn error_with_no_skip(&mut self) -> Option<CompletedMarker> {227		self.error_with_recovery_set_no_default(SyntaxKindSet::ALL)228	}229230	pub fn error_with_recovery_set_no_default(231		&mut self,232		recovery_set: SyntaxKindSet,233	) -> Option<CompletedMarker> {234		let expected_syntax = self235			.expected_syntax236			.take()237			.unwrap_or(ExpectedSyntax::Named("unknown"));238		self.expected_syntax_tracking_state239			.set(ExpectedSyntaxTrackingState::Unnamed);240241		self.skip_trivia();242		if self.at_end() || self.at_ts(recovery_set) {243			let range = self244				.previous_token()245				.map(|t| t.range)246				.unwrap_or_else(|| TextRange::at(TextSize::from(0), TextSize::from(0)));247248			self.events.push(Event::Error(SyntaxError::Missing {249				expected: expected_syntax,250				offset: range.end(),251			}));252			return None;253		}254255		let current_token = self.current_token();256257		self.events.push(Event::Error(SyntaxError::Unexpected {258			expected: expected_syntax,259			found: current_token.kind,260			range: current_token.range,261		}));262		self.clear_expected_syntaxes();263		self.last_error_token = self.offset;264265		let m = self.start();266		self.bump();267		Some(m.complete(self, SyntaxKind::ERROR))268	}269	fn bump_assert(&mut self, kind: SyntaxKind) {270		self.skip_trivia();271		assert!(self.at(kind), "expected {:?}", kind);272		self.bump_remap(self.current());273	}274	fn bump(&mut self) {275		self.skip_trivia();276		self.bump_remap(self.current());277	}278	fn bump_remap(&mut self, kind: SyntaxKind) {279		self.skip_trivia();280		assert_ne!(self.offset, self.lexemes.len(), "already at end");281		self.events.push(Event::Token { kind });282		self.offset += 1;283		self.clear_expected_syntaxes();284	}285	fn step(&self) {286		use std::fmt::Write;287		let steps = self.steps.get();288		if steps >= 15000000 {289			let mut out = "seems like parsing is stuck".to_owned();290			{291				let last = 20;292				write!(out, "\n\nLast {} events:", last).unwrap();293				for (i, event) in self294					.events295					.iter()296					.skip(self.events.len().saturating_sub(last))297					.enumerate()298				{299					write!(out, "\n{i}. {event:?}").unwrap();300				}301			}302			{303				let next = 20;304				write!(out, "\n\nNext {next} tokens:").unwrap();305				for (i, tok) in self.lexemes.iter().skip(self.offset).take(next).enumerate() {306					write!(out, "\n{i}. {tok:?}").unwrap();307				}308			}309			panic!("{out}")310		}311		self.steps.set(steps + 1);312	}313	fn nth(&self, i: usize) -> SyntaxKind {314		self.step();315		let mut offset = self.offset;316		for _ in 0..i {317			while self318				.lexemes319				.get(offset)320				.map(|l| Trivia::can_cast(l.kind))321				.unwrap_or(false)322			{323				offset += 1;324			}325			offset += 1;326		}327		while self328			.lexemes329			.get(offset)330			.map(|l| Trivia::can_cast(l.kind))331			.unwrap_or(false)332		{333			offset += 1;334		}335		self.lexemes.get(offset).map(|l| l.kind).unwrap_or(EOF)336	}337	fn current(&self) -> SyntaxKind {338		self.nth(0)339	}340	fn skip_trivia(&mut self) {341		while Trivia::can_cast(self.peek_raw()) {342			self.offset += 1;343		}344	}345	fn peek_raw(&mut self) -> SyntaxKind {346		self.lexemes347			.get(self.offset)348			.map(|l| l.kind)349			.unwrap_or(SyntaxKind::EOF)350	}351	#[must_use]352	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {353		self.expected_syntax_tracking_state354			.set(ExpectedSyntaxTrackingState::Named);355		self.expected_syntax = Some(ExpectedSyntax::Named(name));356357		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))358	}359	pub fn at(&mut self, kind: SyntaxKind) -> bool {360		self.nth_at(0, kind)361	}362	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {363		if let ExpectedSyntaxTrackingState::Unnamed = self.expected_syntax_tracking_state.get() {364			self.expected_syntax = Some(ExpectedSyntax::Unnamed(kind));365		}366		self.nth(n) == kind367	}368	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {369		set.contains(self.current())370	}371	pub fn at_end(&mut self) -> bool {372		self.at(EOF)373	}374}375pub(crate) struct ExpectedSyntaxGuard {376	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>,377}378379impl ExpectedSyntaxGuard {380	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntaxTrackingState>>) -> Self {381		Self {382			expected_syntax_tracking_state,383		}384	}385}386387impl Drop for ExpectedSyntaxGuard {388	fn drop(&mut self) {389		self.expected_syntax_tracking_state390			.set(ExpectedSyntaxTrackingState::Unnamed);391	}392}393394#[derive(Debug, Clone, Copy)]395enum ExpectedSyntaxTrackingState {396	Named,397	Unnamed,398}399400fn expr(p: &mut Parser) -> Option<CompletedMarker> {401	expr_binding_power(p, 0)402}403fn expr_binding_power(p: &mut Parser, minimum_binding_power: u8) -> Option<CompletedMarker> {404	let mut lhs = lhs(p)?;405406	while let Some(op) = BinaryOperatorKind::cast(p.current())407		.or_else(|| p.at(T!['{']).then(|| BinaryOperatorKind::MetaObjectApply))408	{409		let (left_binding_power, right_binding_power) = op.binding_power();410		if left_binding_power < minimum_binding_power {411			break;412		}413414		// Object apply is not a real operator, we dont have something to bump415		if op != BinaryOperatorKind::MetaObjectApply {416			p.bump();417		}418419		let m = lhs.wrap(p, LHS_EXPR).precede(p);420		let parsed_rhs = expr_binding_power(p, right_binding_power).is_some();421		lhs = m.complete(422			p,423			if op == BinaryOperatorKind::MetaObjectApply {424				EXPR_OBJ_EXTEND425			} else {426				EXPR_BINARY427			},428		);429430		if !parsed_rhs {431			break;432		}433	}434	Some(lhs)435}436fn compspec(p: &mut Parser) {437	assert!(p.at(T![for]) || p.at(T![if]));438	if p.at(T![for]) {439		let m = p.start();440		p.bump();441		name(p);442		p.expect(T![in]);443		expr(p);444		m.complete(p, FOR_SPEC);445	} else if p.at(T![if]) {446		let m = p.start();447		p.bump();448		expr(p);449		m.complete(p, IF_SPEC);450	} else {451		unreachable!()452	}453}454fn comma(p: &mut Parser) -> bool {455	if p.at(T![,]) {456		p.bump();457		true458	} else {459		false460	}461}462fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {463	if p.at(T![,]) {464		p.bump();465		true466	} else if p.at_ts(set) {467		p.expect_with_no_skip(T![,]);468		p.bump();469		true470	} else {471		false472	}473}474fn field_name(p: &mut Parser) {475	let _e = p.expected_syntax_name("field name");476	let m = p.start();477	if p.at(T!['[']) {478		p.bump();479		expr(p);480		p.expect(T![']']);481		m.complete(p, FIELD_NAME_DYNAMIC);482	} else if p.at(IDENT) {483		name(p);484		m.complete(p, FIELD_NAME_FIXED);485	} else if Text::can_cast(p.current()) {486		text(p);487		m.complete(p, FIELD_NAME_FIXED);488	} else {489		p.error_with_recovery_set(TS![;]);490	}491}492fn visibility(p: &mut Parser) {493	if p.at_ts(TS![: :: :::]) {494		p.bump()495	} else {496		p.error_with_recovery_set(TS![]);497	}498}499fn field(p: &mut Parser) {500	let m = p.start();501	field_name(p);502	let plus = if p.at(T![+]) {503		let r = p.start_ranger();504		p.bump();505		Some(r.finish(p))506	} else {507		None508	};509	let params = if p.at(T!['(']) {510		if let Some(plus) = plus {511			p.custom_error(plus, "can't extend with method");512		}513		params_desc(p);514		if p.at(T![+]) {515			let r = p.start_ranger();516			p.bump();517			p.custom_error(r.finish(p), "can't extend with method");518		}519		true520	} else {521		false522	};523	visibility(p);524	expr(p);525526	if params {527		m.complete(p, FIELD_METHOD)528	} else {529		m.complete(p, FIELD_NORMAL)530	};531}532fn assertion(p: &mut Parser) {533	let m = p.start();534	p.bump_assert(T![assert]);535	expr(p).map(|c| c.wrap(p, LHS_EXPR));536	if p.at(T![:]) {537		p.bump();538		expr(p);539	}540	m.complete(p, ASSERTION);541}542fn object(p: &mut Parser) -> CompletedMarker {543	let m_t = p.start();544	let m = p.start();545	p.bump_assert(T!['{']);546547	loop {548		if p.at(T!['}']) {549			p.bump();550			break;551		}552		let m = p.start();553		if p.at(T![local]) {554			obj_local(p);555			m.complete(p, MEMBER_BIND_STMT)556		} else if p.at(T![assert]) {557			assertion(p);558			m.complete(p, MEMBER_ASSERT_STMT)559		} else {560			field(p);561			while p.at(T![for]) || p.at(T![if]) {562				compspec(p)563			}564			m.complete(p, MEMBER_FIELD)565		};566		if comma_with_alternatives(p, SyntaxKindSet::new(&[T![=]])) {567			continue;568		}569		p.expect(R_BRACE);570		break;571	}572573	m.complete(p, OBJ_BODY_MEMBER_LIST);574	m_t.complete(p, EXPR_OBJECT)575}576fn param(p: &mut Parser) {577	let m = p.start();578	destruct(p);579	if p.at(T![=]) {580		p.bump();581		expr(p);582	}583	m.complete(p, PARAM);584}585fn params_desc(p: &mut Parser) -> CompletedMarker {586	let m = p.start();587	p.bump_assert(T!['(']);588589	loop {590		if p.at(T![')']) {591			p.bump();592			break;593		}594		param(p);595		if comma(p) {596			continue;597		}598		p.expect(T![')']);599		break;600	}601602	m.complete(p, PARAMS_DESC)603}604fn args_desc(p: &mut Parser) {605	let m = p.start();606	p.bump_assert(T!['(']);607608	let started_named = Cell::new(false);609610	loop {611		if p.at(T![')']) {612			break;613		}614615		let m = p.start();616		if p.at(IDENT) && p.nth_at(1, T![=]) {617			name(p);618			p.bump();619			expr(p);620			m.complete(p, ARG);621			started_named.set(true);622		} else {623			expr(p);624			m.complete(p, ARG);625		}626		if comma(p) {627			continue;628		}629		break;630	}631	p.expect(T![')']);632	if p.at(T![tailstrict]) {633		p.bump()634	}635	m.complete(p, ARGS_DESC);636}637638fn array(p: &mut Parser) -> CompletedMarker {639	// Start the list node640	let m = p.start();641	p.bump_assert(T!['[']);642643	// This vec will have at most one element in case of correct input644	let mut compspecs = Vec::with_capacity(1);645	let mut elems = 0;646647	loop {648		if p.at(T![']']) {649			p.bump();650			break;651		}652		elems += 1;653		expr(p);654		let c = p.start_ranger();655		let mut had_spec = false;656		while p.at(T![for]) || p.at(T![if]) {657			had_spec = true;658			compspec(p)659		}660		if had_spec {661			compspecs.push(c.finish(p));662		}663		if comma(p) {664			continue;665		}666		p.expect(T![']']);667		break;668	}669670	if elems > 1 && !compspecs.is_empty() {671		for spec in compspecs {672			p.custom_error(673				spec,674				"compspec may only be used if there is only one array element",675			)676		}677678		m.complete(p, EXPR_ARRAY)679	} else if !compspecs.is_empty() {680		m.complete(p, EXPR_ARRAY_COMP)681	} else {682		m.complete(p, EXPR_ARRAY)683	}684}685/// Returns true if it was slice, false if just index686#[must_use]687fn slice_desc_or_index(p: &mut Parser) -> bool {688	let m = p.start();689	p.bump();690	// TODO: do not treat :, ::, ::: as full tokens?691	// Start692	if !p.at(T![:]) && !p.at(T![::]) {693		expr(p);694	}695	if p.at(T![:]) {696		p.bump();697		// End698		if !p.at(T![']']) {699			expr(p).map(|c| c.wrap(p, SLICE_DESC_END));700		}701		if p.at(T![:]) {702			p.bump();703			// Step704			if !p.at(T![']']) {705				expr(p).map(|c| c.wrap(p, SLICE_DESC_STEP));706			}707		}708	} else if p.at(T![::]) {709		p.bump();710		// End711		if !p.at(T![']']) {712			expr(p).map(|c| c.wrap(p, SLICE_DESC_END));713		}714	} else {715		// It was not a slice716		p.expect(T![']']);717		m.forget(p);718		return false;719	}720	p.expect(T![']']);721	m.complete(p, SLICE_DESC);722	true723}724fn lhs(p: &mut Parser) -> Option<CompletedMarker> {725	let mut lhs = lhs_basic(p)?;726727	loop {728		if p.at(T![.]) {729			let m = lhs.precede(p);730			p.bump();731			name(p);732			lhs = m.complete(p, EXPR_INDEX);733		} else if p.at(T!['[']) {734			if slice_desc_or_index(p) {735				lhs = lhs.precede(p).complete(p, EXPR_SLICE);736			} else {737				lhs = lhs738					.wrap(p, LHS_EXPR)739					.precede(p)740					.complete(p, EXPR_INDEX_EXPR);741			}742		} else if p.at(T!['(']) {743			let m = lhs.precede(p);744			args_desc(p);745			lhs = m.complete(p, EXPR_APPLY);746		} else {747			break;748		}749	}750751	Some(lhs)752}753fn name(p: &mut Parser) {754	let m = p.start();755	p.expect(IDENT);756	m.complete(p, NAME);757}758fn destruct_rest(p: &mut Parser) {759	let m = p.start();760	p.bump_assert(T![...]);761	if p.at(IDENT) {762		p.bump()763	}764	m.complete(p, DESTRUCT_REST);765}766fn destruct_object_field(p: &mut Parser) {767	let m = p.start();768	name(p);769	if p.at(T![:]) {770		p.bump();771		destruct(p);772	};773	if p.at(T![=]) {774		p.bump();775		expr(p);776	}777	m.complete(p, DESTRUCT_OBJECT_FIELD);778}779fn obj_local(p: &mut Parser) {780	let m = p.start();781	p.bump_assert(T![local]);782	bind(p);783	m.complete(p, OBJ_LOCAL);784}785fn destruct(p: &mut Parser) -> CompletedMarker {786	let m = p.start();787	if p.at(T![?]) {788		p.bump();789		m.complete(p, DESTRUCT_SKIP)790	} else if p.at(T!['[']) {791		p.bump();792		let mut had_rest = false;793		loop {794			if p.at(T![']']) {795				p.bump();796				break;797			} else if p.at(T![...]) {798				let m_err = p.start_ranger();799				destruct_rest(p);800				if had_rest {801					p.custom_error(m_err.finish(p), "only one rest can be present in array");802				}803				had_rest = true;804			} else {805				destruct(p);806			}807			if p.at(T![,]) {808				p.bump();809				continue;810			}811			p.expect(T![']']);812			break;813		}814		m.complete(p, DESTRUCT_ARRAY)815	} else if p.at(T!['{']) {816		p.bump();817		let mut had_rest = false;818		loop {819			if p.at(T!['}']) {820				p.bump();821				break;822			} else if p.at(T![...]) {823				let m_err = p.start_ranger();824				destruct_rest(p);825				if had_rest {826					p.custom_error(m_err.finish(p), "only one rest can be present in object");827				}828				had_rest = true;829			} else {830				if had_rest {831					p.error_with_recovery_set(TS![]);832				}833				destruct_object_field(p);834			}835			if p.at(T![,]) {836				p.bump();837				continue;838			}839			p.expect(T!['}']);840			break;841		}842		m.complete(p, DESTRUCT_OBJECT)843	} else if p.at(IDENT) {844		name(p);845		m.complete(p, DESTRUCT_FULL)846	} else {847		m.complete(p, ERROR)848	}849}850fn bind(p: &mut Parser) {851	let m = p.start();852	if p.at(IDENT) && p.nth_at(1, T!['(']) {853		name(p);854		params_desc(p);855		p.expect(T![=]);856		expr(p);857		m.complete(p, BIND_FUNCTION)858	} else {859		destruct(p);860		p.expect(T![=]);861		expr(p);862		m.complete(p, BIND_DESTRUCT)863	};864}865fn text(p: &mut Parser) {866	assert!(Text::can_cast(p.current()));867	p.bump();868}869fn number(p: &mut Parser) {870	assert!(Number::can_cast(p.current()));871	p.bump();872}873fn literal(p: &mut Parser) {874	assert!(Literal::can_cast(p.current()));875	p.bump();876}877fn lhs_basic(p: &mut Parser) -> Option<CompletedMarker> {878	let _e = p.expected_syntax_name("value");879	Some(if Literal::can_cast(p.current()) {880		let m = p.start();881		literal(p);882		m.complete(p, EXPR_LITERAL)883	} else if Text::can_cast(p.current()) {884		let m = p.start();885		text(p);886		m.complete(p, EXPR_STRING)887	} else if Number::can_cast(p.current()) {888		let m = p.start();889		number(p);890		m.complete(p, EXPR_NUMBER)891	} else if p.at(IDENT) {892		let m = p.start();893		name(p);894		m.complete(p, EXPR_VAR)895	} else if p.at(INTRINSIC_THIS_FILE) {896		let m = p.start();897		p.bump();898		m.complete(p, EXPR_INTRINSIC_THIS_FILE)899	} else if p.at(INTRINSIC_ID) {900		let m = p.start();901		p.bump();902		m.complete(p, EXPR_INTRINSIC_ID)903	} else if p.at(INTRINSIC) {904		let m = p.start();905		p.bump();906		p.expect(T!['(']);907		name(p);908		p.expect(T![')']);909		m.complete(p, EXPR_INTRINSIC)910	} else if p.at(T![if]) {911		let m = p.start();912		p.bump();913		expr(p);914		p.expect(T![then]);915		expr(p).map(|c| c.wrap(p, TRUE_EXPR));916		if p.at(T![else]) {917			p.bump();918			expr(p).map(|c| c.wrap(p, FALSE_EXPR));919		}920		m.complete(p, EXPR_IF_THEN_ELSE)921	} else if p.at(T!['[']) {922		array(p)923	} else if p.at(T!['{']) {924		object(p)925	} else if p.at(T![local]) {926		let m = p.start();927		p.bump();928		loop {929			if p.at(T![;]) {930				p.bump();931				break;932			}933			bind(p);934935			if p.at(T![,]) {936				p.bump();937				continue;938			}939			p.expect(T![;]);940			break;941		}942		expr(p);943		m.complete(p, EXPR_LOCAL)944	} else if p.at(T![function]) {945		let m = p.start();946		p.bump();947		params_desc(p);948		expr(p);949		m.complete(p, EXPR_FUNCTION)950	} else if p.at(T![error]) {951		let m = p.start();952		p.bump();953		expr(p);954		m.complete(p, EXPR_ERROR)955	} else if p.at(T![assert]) {956		let m = p.start();957		assertion(p);958		p.expect(T![;]);959		expr(p);960		m.complete(p, EXPR_ASSERT)961	} else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {962		let m = p.start();963		p.bump();964		text(p);965		m.complete(p, EXPR_IMPORT)966	} else if let Some(op) = UnaryOperatorKind::cast(p.current()) {967		let ((), right_binding_power) = op.binding_power();968969		let m = p.start();970		p.bump();971		expr_binding_power(p, right_binding_power);972		m.complete(p, EXPR_UNARY)973	} else if p.at(T!['(']) {974		let m = p.start();975		p.bump();976		expr(p);977		p.expect(T![')']);978		m.complete(p, EXPR_PARENED)979	} else {980		p.error_with_recovery_set(TS![]);981		return None;982	})983}984985impl Parse {986	pub fn syntax(&self) -> SyntaxNode {987		SyntaxNode::new_root(self.green_node.clone())988	}989}