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

1use std::{cell::Cell, fmt, rc::Rc};23use miette::{LabeledSpan, SourceOffset, SourceSpan};4use rowan::{GreenNode, TextRange};56use crate::{7	event::Event,8	marker::{CompletedMarker, Marker, Ranger},9	nodes::{BinaryOperatorKind, Literal, Number, Text, UnaryOperatorKind},10	token_set::SyntaxKindSet,11	AstToken, SyntaxKind,12	SyntaxKind::*,13	SyntaxNode, T, TS,14};1516pub struct Parse {17	pub green_node: GreenNode,18	pub errors: Vec<LocatedSyntaxError>,19}2021pub struct Parser {22	// TODO: remove all trivia before feeding to parser?23	kinds: Vec<SyntaxKind>,24	pub offset: usize,25	pub events: Vec<Event>,26	pub entered: u32,27	pub hints: Vec<(u32, TextRange, String)>,28	pub last_error_token: usize,29	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,30	steps: Cell<u64>,31}3233#[derive(Clone, Debug)]34pub enum SyntaxError {35	Unexpected {36		expected: ExpectedSyntax,37		found: SyntaxKind,38	},39	Missing {40		expected: ExpectedSyntax,41	},42	Custom {43		error: String,44	},45	Hint {46		error: String,47	},48}4950#[derive(Debug)]51pub struct LocatedSyntaxError {52	pub error: SyntaxError,53	pub range: TextRange,54}5556impl From<LocatedSyntaxError> for LabeledSpan {57	fn from(val: LocatedSyntaxError) -> Self {58		let span = SourceSpan::new(59			SourceOffset::from(usize::from(val.range.start())),60			SourceOffset::from(usize::from(val.range.end() - val.range.start())),61		);62		dbg!(&val);63		match val.error {64			SyntaxError::Unexpected { expected, found } => LabeledSpan::new_with_span(65				Some(format!("expected {expected}, found {found:?}")),66				span,67			),68			SyntaxError::Missing { expected } => {69				LabeledSpan::new_with_span(Some(format!("missing {expected}")), span)70			}71			SyntaxError::Custom { error } | SyntaxError::Hint { error } => {72				LabeledSpan::new_with_span(Some(error), span)73			}74		}75	}76}7778impl Parser {79	pub fn new(kinds: Vec<SyntaxKind>) -> Self {80		Self {81			kinds,82			offset: 0,83			events: vec![],84			entered: 0,85			last_error_token: 0,86			hints: vec![],87			expected_syntax_tracking_state: Rc::new(Cell::new(ExpectedSyntax::Unnamed(TS![]))),88			steps: Cell::new(0),89		}90	}91	pub fn clear_outdated_hints(&mut self) {92		let amount = self93			.hints94			.iter()95			.rev()96			.take_while(|h| h.0 > self.entered)97			.count();98		self.hints.truncate(self.hints.len() - amount)99	}100	fn clear_expected_syntaxes(&mut self) {101		self.expected_syntax_tracking_state102			.set(ExpectedSyntax::Unnamed(TS![]));103	}104	pub fn start(&mut self) -> Marker {105		let start_event_idx = self.events.len();106		self.events.push(Event::Pending);107		self.entered += 1;108		Marker::new(start_event_idx)109	}110	pub fn start_ranger(&mut self) -> Ranger {111		let pos = self.offset;112		Ranger { pos }113	}114	pub fn parse(mut self) -> Vec<Event> {115		let m = self.start();116		expr(&mut self);117		if !self.at(EOF) {118			let m = self.start();119			while !self.at(EOF) {120				self.bump();121			}122			m.complete_error(&mut self, "unexpected tokens after end");123		}124		m.complete(&mut self, SOURCE_FILE);125126		self.events127	}128129	pub(crate) fn expect(&mut self, kind: SyntaxKind) {130		self.expect_with_recovery_set(kind, TS![])131	}132133	pub(crate) fn expect_with_recovery_set(134		&mut self,135		kind: SyntaxKind,136		recovery_set: SyntaxKindSet,137	) {138		if self.at(kind) {139			if kind != EOF {140				self.bump();141			}142		} else {143			self.error_with_recovery_set(recovery_set);144		}145	}146147	pub(crate) fn expect_with_no_skip(&mut self, kind: SyntaxKind) {148		if self.at(kind) {149			self.bump();150		} else {151			self.error_with_no_skip();152		}153	}154	pub fn error_with_no_skip(&mut self) -> CompletedMarker {155		self.error_with_recovery_set(SyntaxKindSet::ALL)156	}157158	pub fn error_with_recovery_set(&mut self, recovery_set: SyntaxKindSet) -> CompletedMarker {159		let expected = self.expected_syntax_tracking_state.get();160		self.expected_syntax_tracking_state161			.set(ExpectedSyntax::Unnamed(TS![]));162163		if self.at_end() || self.at_ts(recovery_set) {164			let m = self.start();165			return m.complete_missing(self, expected);166		}167168		let current_token = self.current();169170		self.last_error_token = self.offset;171172		let m = self.start();173		self.bump();174		let m = m.complete_unexpected(self, expected, current_token);175		self.clear_expected_syntaxes();176		m177	}178	fn bump_assert(&mut self, kind: SyntaxKind) {179		assert!(self.at(kind), "expected {:?}", kind);180		self.bump_remap(self.current());181	}182	fn bump(&mut self) {183		self.bump_remap(self.current());184	}185	fn bump_remap(&mut self, kind: SyntaxKind) {186		assert_ne!(self.offset, self.kinds.len(), "already at end");187		self.events.push(Event::Token { kind });188		self.offset += 1;189		self.clear_expected_syntaxes();190	}191	fn step(&self) {192		use std::fmt::Write;193		let steps = self.steps.get();194		if steps >= 15000000 {195			let mut out = "seems like parsing is stuck".to_owned();196			{197				let last = 20;198				write!(out, "\n\nLast {} events:", last).unwrap();199				for (i, event) in self200					.events201					.iter()202					.skip(self.events.len().saturating_sub(last))203					.enumerate()204				{205					write!(out, "\n{i}. {event:?}").unwrap();206				}207			}208			{209				let next = 20;210				write!(out, "\n\nNext {next} tokens:").unwrap();211				for (i, tok) in self.kinds.iter().skip(self.offset).take(next).enumerate() {212					write!(out, "\n{i}. {tok:?}").unwrap();213				}214			}215			panic!("{out}")216		}217		self.steps.set(steps + 1);218	}219	fn nth(&self, i: usize) -> SyntaxKind {220		self.step();221		let mut offset = self.offset;222		for _ in 0..i {223			offset += 1;224		}225		self.kinds.get(offset).copied().unwrap_or(EOF)226	}227	fn current(&self) -> SyntaxKind {228		self.nth(0)229	}230	#[must_use]231	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {232		self.expected_syntax_tracking_state233			.set(ExpectedSyntax::Named(name));234235		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))236	}237	pub fn at(&mut self, kind: SyntaxKind) -> bool {238		self.nth_at(0, kind)239	}240	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {241		if n == 0 {242			if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {243				let kinds = kinds.with(kind);244				self.expected_syntax_tracking_state245					.set(ExpectedSyntax::Unnamed(kinds))246			}247		}248		self.nth(n) == kind249	}250	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {251		if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {252			let kinds = kinds.union(set);253			self.expected_syntax_tracking_state254				.set(ExpectedSyntax::Unnamed(kinds))255		}256		set.contains(self.current())257	}258	pub fn at_end(&mut self) -> bool {259		self.at(EOF)260	}261}262pub(crate) struct ExpectedSyntaxGuard {263	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,264}265266impl ExpectedSyntaxGuard {267	fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>) -> Self {268		Self {269			expected_syntax_tracking_state,270		}271	}272}273274impl Drop for ExpectedSyntaxGuard {275	fn drop(&mut self) {276		self.expected_syntax_tracking_state277			.set(ExpectedSyntax::Unnamed(TS![]));278	}279}280281#[derive(Clone, Debug, Copy)]282pub enum ExpectedSyntax {283	Named(&'static str),284	Unnamed(SyntaxKindSet),285}286impl fmt::Display for ExpectedSyntax {287	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {288		match self {289			ExpectedSyntax::Named(name) => write!(f, "{name}"),290			ExpectedSyntax::Unnamed(set) => write!(f, "{set}"),291		}292	}293}294295fn expr(p: &mut Parser) -> CompletedMarker {296	while p.at(T![local]) {297		let m = p.start();298299		p.bump();300		loop {301			if p.at(T![;]) {302				p.bump();303				break;304			}305			bind(p);306307			if p.at(T![,]) {308				p.bump();309				continue;310			}311			p.expect(T![;]);312			break;313		}314		m.complete(p, STMT_LOCAL);315	}316	match expr_binding_power(p, 0) {317		Ok(m) => m,318		Err(m) => m,319	}320}321fn expr_binding_power(322	p: &mut Parser,323	minimum_binding_power: u8,324) -> Result<CompletedMarker, CompletedMarker> {325	let mut lhs = lhs(p)?;326327	while let Some(op) = BinaryOperatorKind::cast(p.current())328		.or_else(|| p.at(T!['{']).then_some(BinaryOperatorKind::MetaObjectApply))329	{330		let (left_binding_power, right_binding_power) = op.binding_power();331		if left_binding_power < minimum_binding_power {332			break;333		}334335		// Object apply is not a real operator, we dont have something to bump336		if op != BinaryOperatorKind::MetaObjectApply {337			p.bump();338		}339340		let m = lhs.wrap(p, LHS_EXPR).precede(p);341		let parsed_rhs = expr_binding_power(p, right_binding_power).is_ok();342		lhs = m.complete(343			p,344			if op == BinaryOperatorKind::MetaObjectApply {345				EXPR_OBJ_EXTEND346			} else {347				EXPR_BINARY348			},349		);350351		if !parsed_rhs {352			break;353		}354	}355	Ok(lhs)356}357358const COMPSPEC: SyntaxKindSet = TS![for if];359fn compspec(p: &mut Parser) -> CompletedMarker {360	assert!(p.at_ts(COMPSPEC));361	if p.at(T![for]) {362		let m = p.start();363		p.bump();364		name(p);365		p.expect(T![in]);366		expr(p);367		m.complete(p, FOR_SPEC)368	} else if p.at(T![if]) {369		let m = p.start();370		p.bump();371		expr(p);372		m.complete(p, IF_SPEC)373	} else {374		unreachable!()375	}376}377378fn comma(p: &mut Parser) -> bool {379	comma_with_alternatives(p, TS![])380}381fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {382	if p.at(T![,]) {383		p.bump();384		true385	} else if p.at_ts(set) {386		let _ex = p.expected_syntax_name("comma");387		p.expect_with_recovery_set(T![,], TS![]);388		true389	} else {390		false391	}392}393394fn field_name(p: &mut Parser) {395	let _e = p.expected_syntax_name("field name");396	let m = p.start();397	if p.at(T!['[']) {398		p.bump();399		expr(p);400		p.expect(T![']']);401		m.complete(p, FIELD_NAME_DYNAMIC);402	} else if p.at(IDENT) {403		name(p);404		m.complete(p, FIELD_NAME_FIXED);405	} else if Text::can_cast(p.current()) {406		text(p);407		m.complete(p, FIELD_NAME_FIXED);408	} else {409		m.forget(p);410		p.error_with_recovery_set(TS![; : :: ::: '(']);411	}412}413fn visibility(p: &mut Parser) {414	if p.at_ts(TS![: :: :::]) {415		p.bump()416	} else {417		p.error_with_recovery_set(TS![=]);418	}419}420fn assertion(p: &mut Parser) {421	let m = p.start();422	p.bump_assert(T![assert]);423	expr(p).wrap(p, LHS_EXPR);424	if p.at(T![:]) {425		p.bump();426		expr(p);427	}428	m.complete(p, ASSERTION);429}430fn object(p: &mut Parser) -> CompletedMarker {431	let m_t = p.start();432	let m = p.start();433	p.bump_assert(T!['{']);434435	let mut elems = 0;436	let mut compspecs = Vec::new();437	let mut asserts = Vec::new();438	loop {439		if p.at(T!['}']) {440			p.bump();441			break;442		}443		if p.at_ts(COMPSPEC) {444			if elems == 0 {445				let m = p.start();446				m.complete_missing(p, ExpectedSyntax::Named("field definition"));447			}448			while p.at_ts(COMPSPEC) {449				compspecs.push(compspec(p));450			}451			if comma_with_alternatives(p, TS![;]) {452				continue;453			}454			p.expect(R_BRACE);455			break;456		}457		let m = p.start();458		if p.at(T![local]) {459			obj_local(p);460			m.complete(p, MEMBER_BIND_STMT);461		} else if p.at(T![assert]) {462			assertion(p);463			asserts.push(m.complete(p, MEMBER_ASSERT_STMT));464		} else {465			field_name(p);466			if p.at(T![+]) {467				p.bump();468			}469			let params = if p.at(T!['(']) {470				params_desc(p);471				visibility(p);472				expr(p);473				true474			} else if p.at_ts(TS![: :: :::]) && p.nth_at(1, T![function]) {475				visibility(p);476				p.bump_assert(T![function]);477				params_desc(p);478				expr(p);479				true480			} else {481				visibility(p);482				expr(p);483				false484			};485			elems += 1;486487			if params {488				m.complete(p, MEMBER_FIELD_METHOD)489			} else {490				m.complete(p, MEMBER_FIELD_NORMAL)491			};492		};493		while p.at_ts(COMPSPEC) {494			compspecs.push(compspec(p));495		}496		if comma_with_alternatives(p, TS![;]) {497			continue;498		}499		p.expect(R_BRACE);500		break;501	}502503	if elems > 1 && !compspecs.is_empty() {504		for errored in compspecs {505			errored.wrap_error(506				p,507				"compspec may only be used if there is only one array element",508			);509		}510		m.complete(p, OBJ_BODY_MEMBER_LIST);511	} else if !compspecs.is_empty() {512		for errored in asserts {513			errored.wrap_error(p, "asserts can't be used in object comprehensions");514		}515		m.complete(p, OBJ_BODY_COMP);516	} else {517		m.complete(p, OBJ_BODY_MEMBER_LIST);518	}519	m_t.complete(p, EXPR_OBJECT)520}521fn param(p: &mut Parser) {522	let m = p.start();523	destruct(p);524	if p.at(T![=]) {525		p.bump();526		expr(p);527	}528	m.complete(p, PARAM);529}530fn params_desc(p: &mut Parser) -> CompletedMarker {531	let m = p.start();532	p.bump_assert(T!['(']);533534	loop {535		if p.at(T![')']) {536			p.bump();537			break;538		}539		param(p);540		if comma(p) {541			continue;542		}543		p.expect(T![')']);544		break;545	}546547	m.complete(p, PARAMS_DESC)548}549fn args_desc(p: &mut Parser) {550	let m = p.start();551	p.bump_assert(T!['(']);552553	let started_named = Cell::new(false);554	let mut unnamed_after_named = Vec::new();555556	loop {557		if p.at(T![')']) {558			break;559		}560561		let m = p.start();562		if p.at(IDENT) && p.nth_at(1, T![=]) {563			name(p);564			p.bump();565			expr(p);566			m.complete(p, ARG);567			started_named.set(true);568		} else {569			expr(p);570			let arg = m.complete(p, ARG);571			if started_named.get() {572				unnamed_after_named.push(arg)573			}574		}575		if comma(p) {576			continue;577		}578		break;579	}580	p.expect(T![')']);581	if p.at(T![tailstrict]) {582		p.bump()583	}584585	for errored in unnamed_after_named {586		errored.wrap_error(p, "can't use positional arguments after named");587	}588589	m.complete(p, ARGS_DESC);590}591592fn array(p: &mut Parser) -> CompletedMarker {593	// Start the list node594	let m = p.start();595	p.bump_assert(T!['[']);596597	let mut compspecs = Vec::new();598	let mut elems = 0;599600	loop {601		if p.at(T![']']) {602			p.bump();603			break;604		}605		if elems != 0 && p.at_ts(COMPSPEC) {606			while p.at_ts(COMPSPEC) {607				compspecs.push(compspec(p));608			}609			if comma(p) {610				continue;611			}612			p.expect(T![']']);613			break;614		}615		elems += 1;616		expr(p);617		while p.at_ts(COMPSPEC) {618			compspecs.push(compspec(p));619		}620		if comma(p) {621			continue;622		}623		p.expect(T![']']);624		break;625	}626627	if elems > 1 && !compspecs.is_empty() {628		for spec in compspecs {629			spec.wrap_error(630				p,631				"compspec may only be used if there is only one array element",632			);633		}634635		m.complete(p, EXPR_ARRAY)636	} else if !compspecs.is_empty() {637		m.complete(p, EXPR_ARRAY_COMP)638	} else {639		m.complete(p, EXPR_ARRAY)640	}641}642/// Returns true if it was slice, false if just index643#[must_use]644fn slice_desc_or_index(p: &mut Parser) -> bool {645	let m = p.start();646	p.bump();647	// TODO: do not treat :, ::, ::: as full tokens?648	// Start649	if !p.at(T![:]) && !p.at(T![::]) {650		expr(p);651	}652	if p.at(T![:]) {653		p.bump();654		// End655		if !p.at(T![']']) {656			expr(p).wrap(p, SLICE_DESC_END);657		}658		if p.at(T![:]) {659			p.bump();660			// Step661			if !p.at(T![']']) {662				expr(p).wrap(p, SLICE_DESC_STEP);663			}664		}665	} else if p.at(T![::]) {666		p.bump();667		// End668		if !p.at(T![']']) {669			expr(p).wrap(p, SLICE_DESC_END);670		}671	} else {672		// It was not a slice673		p.expect(T![']']);674		m.forget(p);675		return false;676	}677	p.expect(T![']']);678	m.complete(p, SLICE_DESC);679	true680}681682fn lhs(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {683	let mut lhs = lhs_basic(p)?;684685	loop {686		if p.at(T![.]) {687			let m = lhs.precede(p);688			p.bump();689			name(p);690			lhs = m.complete(p, EXPR_INDEX);691		} else if p.at(T!['[']) {692			if slice_desc_or_index(p) {693				lhs = lhs.precede(p).complete(p, EXPR_SLICE);694			} else {695				lhs = lhs696					.wrap(p, LHS_EXPR)697					.precede(p)698					.complete(p, EXPR_INDEX_EXPR);699			}700		} else if p.at(T!['(']) {701			let m = lhs.precede(p);702			args_desc(p);703			lhs = m.complete(p, EXPR_APPLY);704		} else {705			break;706		}707	}708709	Ok(lhs)710}711fn name(p: &mut Parser) {712	let m = p.start();713	p.expect(IDENT);714	m.complete(p, NAME);715}716fn destruct_rest(p: &mut Parser) {717	let m = p.start();718	p.bump_assert(T![...]);719	if p.at(IDENT) {720		p.bump()721	}722	m.complete(p, DESTRUCT_REST);723}724fn destruct_object_field(p: &mut Parser) {725	let m = p.start();726	name(p);727	if p.at(T![:]) {728		p.bump();729		destruct(p);730	};731	if p.at(T![=]) {732		p.bump();733		expr(p);734	}735	m.complete(p, DESTRUCT_OBJECT_FIELD);736}737fn obj_local(p: &mut Parser) {738	let m = p.start();739	p.bump_assert(T![local]);740	bind(p);741	m.complete(p, OBJ_LOCAL);742}743fn destruct(p: &mut Parser) -> CompletedMarker {744	let m = p.start();745	let _ex = p.expected_syntax_name("destruction specifier");746	if p.at(T![?]) {747		p.bump();748		m.complete(p, DESTRUCT_SKIP)749	} else if p.at(T!['[']) {750		p.bump();751		let mut had_rest = false;752		loop {753			if p.at(T![']']) {754				p.bump();755				break;756			} else if p.at(T![...]) {757				let m_err = p.start_ranger();758				destruct_rest(p);759				// if had_rest {760				// 	p.custom_error(m_err.finish(p), "only one rest can be present in array");761				// }762				had_rest = true;763			} else {764				destruct(p);765			}766			if p.at(T![,]) {767				p.bump();768				continue;769			}770			p.expect(T![']']);771			break;772		}773		m.complete(p, DESTRUCT_ARRAY)774	} else if p.at(T!['{']) {775		p.bump();776		let mut had_rest = false;777		loop {778			if p.at(T!['}']) {779				p.bump();780				break;781			} else if p.at(T![...]) {782				let m_err = p.start_ranger();783				destruct_rest(p);784				// if had_rest {785				// 	p.custom_error(m_err.finish(p), "only one rest can be present in object");786				// }787				had_rest = true;788			} else {789				if had_rest {790					p.error_with_recovery_set(TS![]);791				}792				destruct_object_field(p);793			}794			if p.at(T![,]) {795				p.bump();796				continue;797			}798			p.expect(T!['}']);799			break;800		}801		m.complete(p, DESTRUCT_OBJECT)802	} else if p.at(IDENT) {803		name(p);804		m.complete(p, DESTRUCT_FULL)805	} else {806		m.forget(p);807		p.error_with_recovery_set(TS![; , '}', '(', :])808	}809}810fn bind(p: &mut Parser) {811	let m = p.start();812	if p.at(IDENT) && p.nth_at(1, T!['(']) {813		name(p);814		params_desc(p);815		p.expect(T![=]);816		expr(p);817		m.complete(p, BIND_FUNCTION)818	} else if p.at(IDENT) && p.nth_at(1, T![=]) && p.nth_at(2, T![function]) {819		name(p);820		p.expect(T![=]);821		p.expect(T![function]);822		params_desc(p);823		expr(p);824		m.complete(p, BIND_FUNCTION)825	} else {826		destruct(p);827		p.expect(T![=]);828		expr(p);829		m.complete(p, BIND_DESTRUCT)830	};831}832fn text(p: &mut Parser) {833	assert!(Text::can_cast(p.current()));834	p.bump();835}836fn number(p: &mut Parser) {837	assert!(Number::can_cast(p.current()));838	p.bump();839}840fn literal(p: &mut Parser) {841	assert!(Literal::can_cast(p.current()));842	p.bump();843}844fn lhs_basic(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {845	let _e = p.expected_syntax_name("expression");846	Ok(if Literal::can_cast(p.current()) {847		let m = p.start();848		literal(p);849		m.complete(p, EXPR_LITERAL)850	} else if Text::can_cast(p.current()) {851		let m = p.start();852		text(p);853		m.complete(p, EXPR_STRING)854	} else if Number::can_cast(p.current()) {855		let m = p.start();856		number(p);857		m.complete(p, EXPR_NUMBER)858	} else if p.at(IDENT) {859		let m = p.start();860		name(p);861		m.complete(p, EXPR_VAR)862	} else if p.at(T![if]) {863		let m = p.start();864		p.bump();865		expr(p);866		p.expect(T![then]);867		expr(p).wrap(p, TRUE_EXPR);868		if p.at(T![else]) {869			p.bump();870			expr(p).wrap(p, FALSE_EXPR);871		}872		m.complete(p, EXPR_IF_THEN_ELSE)873	} else if p.at(T!['[']) {874		array(p)875	} else if p.at(T!['{']) {876		object(p)877	} else if p.at(T![function]) {878		let m = p.start();879		p.bump();880		params_desc(p);881		expr(p);882		m.complete(p, EXPR_FUNCTION)883	} else if p.at(T![error]) {884		let m = p.start();885		p.bump();886		expr(p);887		m.complete(p, EXPR_ERROR)888	} else if p.at(T![assert]) {889		let m = p.start();890		assertion(p);891		p.expect(T![;]);892		expr(p);893		m.complete(p, EXPR_ASSERT)894	} else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {895		let m = p.start();896		p.bump();897		text(p);898		m.complete(p, EXPR_IMPORT)899	} else if let Some(op) = UnaryOperatorKind::cast(p.current()) {900		let ((), right_binding_power) = op.binding_power();901902		let m = p.start();903		p.bump();904		let _ = expr_binding_power(p, right_binding_power);905		m.complete(p, EXPR_UNARY)906	} else if p.at(T!['(']) {907		let m = p.start();908		p.bump();909		expr(p);910		p.expect(T![')']);911		m.complete(p, EXPR_PARENED)912	} else {913		return Err(p.error_with_no_skip());914	})915}916917impl Parse {918	pub fn syntax(&self) -> SyntaxNode {919		SyntaxNode::new_root(self.green_node.clone())920	}921}