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 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 let m = p.start();297 while p.at(T![local]) || p.at(T![assert]) {298 let m = p.start();299300 if p.at(T![local]) {301 p.bump();302 loop {303 if p.at(T![;]) {304 p.bump();305 break;306 }307 bind(p);308309 if p.at(T![,]) {310 p.bump();311 continue;312 }313 p.expect(T![;]);314 break;315 }316 m.complete(p, STMT_LOCAL);317 } else {318 assertion(p);319 p.expect(T![;]);320 m.complete(p, STMT_ASSERT);321 }322 }323 match expr_binding_power(p, 0) {324 Ok(m) => m,325 Err(m) => m,326 };327 m.complete(p, EXPR)328}329fn expr_binding_power(330 p: &mut Parser,331 minimum_binding_power: u8,332) -> Result<CompletedMarker, CompletedMarker> {333 let mut lhs = lhs(p)?;334335 while let Some(op) = BinaryOperatorKind::cast(p.current())336 .or_else(|| p.at(T!['{']).then_some(BinaryOperatorKind::MetaObjectApply))337 {338 let (left_binding_power, right_binding_power) = op.binding_power();339 if left_binding_power < minimum_binding_power {340 break;341 }342343 344 if op != BinaryOperatorKind::MetaObjectApply {345 p.bump();346 }347348 let m = lhs.wrap(p, EXPR).precede(p);349 let parsed_rhs = expr_binding_power(p, right_binding_power)350 .map(|v| v.precede(p).complete(p, EXPR))351 .is_ok();352 lhs = m.complete(353 p,354 if op == BinaryOperatorKind::MetaObjectApply {355 EXPR_OBJ_EXTEND356 } else {357 EXPR_BINARY358 },359 );360361 if !parsed_rhs {362 break;363 }364 }365 Ok(lhs)366}367368const COMPSPEC: SyntaxKindSet = TS![for if];369fn compspec(p: &mut Parser) -> CompletedMarker {370 assert!(p.at_ts(COMPSPEC));371 if p.at(T![for]) {372 let m = p.start();373 p.bump();374 destruct(p);375 p.expect(T![in]);376 expr(p);377 m.complete(p, FOR_SPEC)378 } else if p.at(T![if]) {379 let m = p.start();380 p.bump();381 expr(p);382 m.complete(p, IF_SPEC)383 } else {384 unreachable!()385 }386}387388fn comma(p: &mut Parser) -> bool {389 comma_with_alternatives(p, TS![])390}391fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {392 if p.at(T![,]) {393 p.bump();394 true395 } else if p.at_ts(set) {396 let _ex = p.expected_syntax_name("comma");397 p.expect_with_recovery_set(T![,], TS![]);398 true399 } else {400 false401 }402}403404fn field_name(p: &mut Parser) {405 let _e = p.expected_syntax_name("field name");406 let m = p.start();407 if p.at(T!['[']) {408 p.bump();409 expr(p);410 p.expect(T![']']);411 m.complete(p, FIELD_NAME_DYNAMIC);412 } else if p.at(IDENT) {413 name(p);414 m.complete(p, FIELD_NAME_FIXED);415 } else if Text::can_cast(p.current()) {416 text(p);417 m.complete(p, FIELD_NAME_FIXED);418 } else {419 m.forget(p);420 p.error_with_recovery_set(TS![; : :: ::: '(']);421 }422}423fn visibility(p: &mut Parser) {424 if p.at_ts(TS![: :: :::]) {425 p.bump()426 } else {427 p.error_with_recovery_set(TS![=]);428 }429}430fn assertion(p: &mut Parser) {431 let m = p.start();432 p.bump_assert(T![assert]);433 expr(p);434 if p.at(T![:]) {435 p.bump();436 expr(p);437 }438 m.complete(p, ASSERTION);439}440fn object(p: &mut Parser) -> CompletedMarker {441 let m_t = p.start();442 let m = p.start();443 p.bump_assert(T!['{']);444445 let mut elems = 0;446 let mut compspecs = Vec::new();447 let mut asserts = Vec::new();448 loop {449 if p.at(T!['}']) {450 p.bump();451 break;452 }453 if p.at_ts(COMPSPEC) {454 if elems == 0 {455 let m = p.start();456 m.complete_missing(p, ExpectedSyntax::Named("field definition"));457 }458 while p.at_ts(COMPSPEC) {459 compspecs.push(compspec(p));460 }461 if comma_with_alternatives(p, TS![;]) {462 continue;463 }464 p.expect(R_BRACE);465 break;466 }467 let m = p.start();468 if p.at(T![local]) {469 obj_local(p);470 m.complete(p, MEMBER_BIND_STMT);471 } else if p.at(T![assert]) {472 assertion(p);473 asserts.push(m.complete(p, MEMBER_ASSERT_STMT));474 } else {475 field_name(p);476 if p.at(T![+]) {477 p.bump();478 }479 let params = if p.at(T!['(']) {480 params_desc(p);481 visibility(p);482 expr(p);483 true484 } else if p.at_ts(TS![: :: :::]) && p.nth_at(1, T![function]) {485 visibility(p);486 p.bump_assert(T![function]);487 params_desc(p);488 expr(p);489 true490 } else {491 visibility(p);492 expr(p);493 false494 };495 elems += 1;496497 if params {498 m.complete(p, MEMBER_FIELD_METHOD)499 } else {500 m.complete(p, MEMBER_FIELD_NORMAL)501 };502 };503 while p.at_ts(COMPSPEC) {504 compspecs.push(compspec(p));505 }506 if comma_with_alternatives(p, TS![;]) {507 continue;508 }509 p.expect(R_BRACE);510 break;511 }512513 if elems > 1 && !compspecs.is_empty() {514 for errored in compspecs {515 errored.wrap_error(516 p,517 "compspec may only be used if there is only one object element",518 );519 }520 m.complete(p, OBJ_BODY_MEMBER_LIST);521 } else if !compspecs.is_empty() {522 for errored in asserts {523 errored.wrap_error(p, "asserts can't be used in object comprehensions");524 }525 m.complete(p, OBJ_BODY_COMP);526 } else {527 m.complete(p, OBJ_BODY_MEMBER_LIST);528 }529 m_t.complete(p, EXPR_OBJECT)530}531fn param(p: &mut Parser) {532 let m = p.start();533 destruct(p);534 if p.at(T![=]) {535 p.bump();536 expr(p);537 }538 m.complete(p, PARAM);539}540fn params_desc(p: &mut Parser) -> CompletedMarker {541 let m = p.start();542 p.bump_assert(T!['(']);543544 loop {545 if p.at(T![')']) {546 p.bump();547 break;548 }549 param(p);550 if comma(p) {551 continue;552 }553 p.expect(T![')']);554 break;555 }556557 m.complete(p, PARAMS_DESC)558}559fn args_desc(p: &mut Parser) {560 let m = p.start();561 p.bump_assert(T!['(']);562563 let started_named = Cell::new(false);564 let mut unnamed_after_named = Vec::new();565566 loop {567 if p.at(T![')']) {568 break;569 }570571 let m = p.start();572 if p.at(IDENT) && p.nth_at(1, T![=]) {573 name(p);574 p.bump();575 expr(p);576 m.complete(p, ARG);577 started_named.set(true);578 } else {579 expr(p);580 let arg = m.complete(p, ARG);581 if started_named.get() {582 unnamed_after_named.push(arg)583 }584 }585 if comma(p) {586 continue;587 }588 break;589 }590 p.expect(T![')']);591 if p.at(T![tailstrict]) {592 p.bump()593 }594595 for errored in unnamed_after_named {596 errored.wrap_error(p, "can't use positional arguments after named");597 }598599 m.complete(p, ARGS_DESC);600}601602fn array(p: &mut Parser) -> CompletedMarker {603 604 let m = p.start();605 p.bump_assert(T!['[']);606607 let mut compspecs = Vec::new();608 let mut elems = 0;609610 loop {611 if p.at(T![']']) {612 p.bump();613 break;614 }615 if elems != 0 && p.at_ts(COMPSPEC) {616 while p.at_ts(COMPSPEC) {617 compspecs.push(compspec(p));618 }619 if comma(p) {620 continue;621 }622 p.expect(T![']']);623 break;624 }625 expr(p);626 elems += 1;627 while p.at_ts(COMPSPEC) {628 compspecs.push(compspec(p));629 }630 if comma(p) {631 continue;632 }633 p.expect(T![']']);634 break;635 }636637 if elems > 1 && !compspecs.is_empty() {638 for spec in compspecs {639 spec.wrap_error(640 p,641 "compspec may only be used if there is only one array element",642 );643 }644645 m.complete(p, EXPR_ARRAY)646 } else if !compspecs.is_empty() {647 m.complete(p, EXPR_ARRAY_COMP)648 } else {649 m.complete(p, EXPR_ARRAY)650 }651}652653#[must_use]654fn slice_desc_or_index(p: &mut Parser) -> bool {655 let m = p.start();656 p.bump();657 658 659 if !p.at(T![:]) && !p.at(T![::]) {660 expr(p);661 }662 if p.at(T![:]) {663 p.bump();664 665 if !p.at(T![']']) {666 expr(p).wrap(p, SLICE_DESC_END);667 }668 if p.at(T![:]) {669 p.bump();670 671 if !p.at(T![']']) {672 expr(p).wrap(p, SLICE_DESC_STEP);673 }674 }675 } else if p.at(T![::]) {676 p.bump();677 678 if !p.at(T![']']) {679 expr(p).wrap(p, SLICE_DESC_END);680 }681 } else {682 683 p.expect(T![']']);684 m.forget(p);685 return false;686 }687 p.expect(T![']']);688 m.complete(p, SLICE_DESC);689 true690}691692fn suffix(p: &mut Parser) {693 loop {694 let start = p.start();695 let _marker: CompletedMarker = if p.at(T![?]) {696 p.bump();697 p.expect(T![.]);698 if p.at(IDENT) {699 name(p);700 start.complete(p, SUFFIX_INDEX)701 } else if p.at(T!['[']) {702 p.bump();703 expr(p);704 p.expect(T![']']);705 start.complete(p, SUFFIX_INDEX_EXPR)706 } else {707 start.complete_missing(p, ExpectedSyntax::Named("index"))708 }709 } else if p.at(T![.]) {710 p.bump();711 name(p);712 start.complete(p, SUFFIX_INDEX)713 } else if p.at(T!['[']) {714 if slice_desc_or_index(p) {715 start.complete(p, SUFFIX_SLICE)716 } else {717 start.complete(p, SUFFIX_INDEX_EXPR)718 }719 } else if p.at(T!['(']) {720 args_desc(p);721 start.complete(p, SUFFIX_APPLY)722 } else {723 start.forget(p);724 break;725 };726 }727}728729fn lhs(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {730 let lhs = lhs_basic(p)?;731732 suffix(p);733734 Ok(lhs)735}736fn name(p: &mut Parser) {737 let m = p.start();738 p.expect(IDENT);739 m.complete(p, NAME);740}741fn destruct_rest(p: &mut Parser) {742 let m = p.start();743 p.bump_assert(T![...]);744 if p.at(IDENT) {745 p.bump()746 }747 m.complete(p, DESTRUCT_REST);748}749fn destruct_object_field(p: &mut Parser) {750 let m = p.start();751 name(p);752 if p.at(T![:]) {753 p.bump();754 destruct(p);755 };756 if p.at(T![=]) {757 p.bump();758 expr(p);759 }760 m.complete(p, DESTRUCT_OBJECT_FIELD);761}762fn obj_local(p: &mut Parser) {763 let m = p.start();764 p.bump_assert(T![local]);765 bind(p);766 m.complete(p, OBJ_LOCAL);767}768fn destruct(p: &mut Parser) -> CompletedMarker {769 let m = p.start();770 let _ex = p.expected_syntax_name("destruction specifier");771 if p.at(T![?]) {772 p.bump();773 m.complete(p, DESTRUCT_SKIP)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 785 786 787 had_rest = true;788 } else {789 destruct(p);790 }791 if p.at(T![,]) {792 p.bump();793 continue;794 }795 p.expect(T![']']);796 break;797 }798 m.complete(p, DESTRUCT_ARRAY)799 } else if p.at(T!['{']) {800 p.bump();801 let mut had_rest = false;802 loop {803 if p.at(T!['}']) {804 p.bump();805 break;806 } else if p.at(T![...]) {807 let m_err = p.start_ranger();808 destruct_rest(p);809 810 811 812 had_rest = true;813 } else {814 if had_rest {815 p.error_with_recovery_set(TS![]);816 }817 destruct_object_field(p);818 }819 if p.at(T![,]) {820 p.bump();821 continue;822 }823 p.expect(T!['}']);824 break;825 }826 m.complete(p, DESTRUCT_OBJECT)827 } else if p.at(IDENT) {828 name(p);829 m.complete(p, DESTRUCT_FULL)830 } else {831 m.forget(p);832 p.error_with_recovery_set(TS![; , '}', '(', :])833 }834}835fn bind(p: &mut Parser) {836 let m = p.start();837 if p.at(IDENT) && p.nth_at(1, T!['(']) {838 name(p);839 params_desc(p);840 p.expect(T![=]);841 expr(p);842 m.complete(p, BIND_FUNCTION)843 } else if p.at(IDENT) && p.nth_at(1, T![=]) && p.nth_at(2, T![function]) {844 name(p);845 p.expect(T![=]);846 p.expect(T![function]);847 params_desc(p);848 expr(p);849 m.complete(p, BIND_FUNCTION)850 } else {851 destruct(p);852 p.expect(T![=]);853 expr(p);854 m.complete(p, BIND_DESTRUCT)855 };856}857fn text(p: &mut Parser) {858 assert!(Text::can_cast(p.current()));859 p.bump();860}861fn number(p: &mut Parser) {862 assert!(Number::can_cast(p.current()));863 p.bump();864}865fn literal(p: &mut Parser) {866 assert!(Literal::can_cast(p.current()));867 p.bump();868}869fn lhs_basic(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {870 let _e = p.expected_syntax_name("expression");871 Ok(if Literal::can_cast(p.current()) {872 let m = p.start();873 literal(p);874 m.complete(p, EXPR_LITERAL)875 } else if Text::can_cast(p.current()) {876 let m = p.start();877 text(p);878 m.complete(p, EXPR_STRING)879 } else if Number::can_cast(p.current()) {880 let m = p.start();881 number(p);882 m.complete(p, EXPR_NUMBER)883 } else if p.at(IDENT) {884 let m = p.start();885 name(p);886 m.complete(p, EXPR_VAR)887 } else if p.at(T![if]) {888 let m = p.start();889 p.bump();890 expr(p);891 p.expect(T![then]);892 expr(p).wrap(p, TRUE_EXPR);893 if p.at(T![else]) {894 p.bump();895 expr(p).wrap(p, FALSE_EXPR);896 }897 m.complete(p, EXPR_IF_THEN_ELSE)898 } else if p.at(T!['[']) {899 array(p)900 } else if p.at(T!['{']) {901 object(p)902 } else if p.at(T![function]) {903 let m = p.start();904 p.bump();905 params_desc(p);906 expr(p);907 m.complete(p, EXPR_FUNCTION)908 } else if p.at(T![error]) {909 let m = p.start();910 p.bump();911 expr(p);912 m.complete(p, EXPR_ERROR)913 } else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {914 let m = p.start();915 p.bump();916 text(p);917 m.complete(p, EXPR_IMPORT)918 } else if let Some(op) = UnaryOperatorKind::cast(p.current()) {919 let ((), right_binding_power) = op.binding_power();920921 let m = p.start();922 p.bump();923 let _ = expr_binding_power(p, right_binding_power);924 m.complete(p, EXPR_UNARY)925 } else if p.at(T!['(']) {926 let m = p.start();927 p.bump();928 expr(p);929 p.expect(T![')']);930 m.complete(p, EXPR_PARENED)931 } else {932 return Err(p.error_with_no_skip());933 })934}935936impl Parse {937 pub fn syntax(&self) -> SyntaxNode {938 SyntaxNode::new_root(self.green_node.clone())939 }940}