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 self.expect(EOF);118 m.complete(&mut self, SOURCE_FILE);119120 self.events121 }122123 pub(crate) fn expect(&mut self, kind: SyntaxKind) {124 self.expect_with_recovery_set(kind, TS![])125 }126127 pub(crate) fn expect_with_recovery_set(128 &mut self,129 kind: SyntaxKind,130 recovery_set: SyntaxKindSet,131 ) {132 if self.at(kind) {133 if kind != EOF {134 self.bump();135 }136 } else {137 self.error_with_recovery_set(recovery_set);138 }139 }140141 pub(crate) fn expect_with_no_skip(&mut self, kind: SyntaxKind) {142 if self.at(kind) {143 self.bump();144 } else {145 self.error_with_no_skip();146 }147 }148 pub fn error_with_no_skip(&mut self) -> CompletedMarker {149 self.error_with_recovery_set(SyntaxKindSet::ALL)150 }151152 pub fn error_with_recovery_set(&mut self, recovery_set: SyntaxKindSet) -> CompletedMarker {153 let expected = self.expected_syntax_tracking_state.get();154 self.expected_syntax_tracking_state155 .set(ExpectedSyntax::Unnamed(TS![]));156157 if self.at_end() || self.at_ts(recovery_set) {158 let m = self.start();159 return m.complete_missing(self, expected);160 }161162 let current_token = self.current();163164 self.last_error_token = self.offset;165166 let m = self.start();167 self.bump();168 let m = m.complete_unexpected(self, expected, current_token);169 self.clear_expected_syntaxes();170 m171 }172 fn bump_assert(&mut self, kind: SyntaxKind) {173 assert!(self.at(kind), "expected {:?}", kind);174 self.bump_remap(self.current());175 }176 fn bump(&mut self) {177 self.bump_remap(self.current());178 }179 fn bump_remap(&mut self, kind: SyntaxKind) {180 assert_ne!(self.offset, self.kinds.len(), "already at end");181 self.events.push(Event::Token { kind });182 self.offset += 1;183 self.clear_expected_syntaxes();184 }185 fn step(&self) {186 use std::fmt::Write;187 let steps = self.steps.get();188 if steps >= 15000000 {189 let mut out = "seems like parsing is stuck".to_owned();190 {191 let last = 20;192 write!(out, "\n\nLast {} events:", last).unwrap();193 for (i, event) in self194 .events195 .iter()196 .skip(self.events.len().saturating_sub(last))197 .enumerate()198 {199 write!(out, "\n{i}. {event:?}").unwrap();200 }201 }202 {203 let next = 20;204 write!(out, "\n\nNext {next} tokens:").unwrap();205 for (i, tok) in self.kinds.iter().skip(self.offset).take(next).enumerate() {206 write!(out, "\n{i}. {tok:?}").unwrap();207 }208 }209 panic!("{out}")210 }211 self.steps.set(steps + 1);212 }213 fn nth(&self, i: usize) -> SyntaxKind {214 self.step();215 let mut offset = self.offset;216 for _ in 0..i {217 offset += 1;218 }219 self.kinds.get(offset).copied().unwrap_or(EOF)220 }221 fn current(&self) -> SyntaxKind {222 self.nth(0)223 }224 #[must_use]225 pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {226 self.expected_syntax_tracking_state227 .set(ExpectedSyntax::Named(name));228229 ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))230 }231 pub fn at(&mut self, kind: SyntaxKind) -> bool {232 self.nth_at(0, kind)233 }234 pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {235 if n == 0 {236 if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {237 let kinds = kinds.with(kind);238 self.expected_syntax_tracking_state239 .set(ExpectedSyntax::Unnamed(kinds))240 }241 }242 self.nth(n) == kind243 }244 pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {245 if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {246 let kinds = kinds.union(set);247 self.expected_syntax_tracking_state248 .set(ExpectedSyntax::Unnamed(kinds))249 }250 set.contains(self.current())251 }252 pub fn at_end(&mut self) -> bool {253 self.at(EOF)254 }255}256pub(crate) struct ExpectedSyntaxGuard {257 expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,258}259260impl ExpectedSyntaxGuard {261 fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>) -> Self {262 Self {263 expected_syntax_tracking_state,264 }265 }266}267268impl Drop for ExpectedSyntaxGuard {269 fn drop(&mut self) {270 self.expected_syntax_tracking_state271 .set(ExpectedSyntax::Unnamed(TS![]));272 }273}274275#[derive(Clone, Debug, Copy)]276pub enum ExpectedSyntax {277 Named(&'static str),278 Unnamed(SyntaxKindSet),279}280impl fmt::Display for ExpectedSyntax {281 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {282 match self {283 ExpectedSyntax::Named(name) => write!(f, "{name}"),284 ExpectedSyntax::Unnamed(set) => write!(f, "{set}"),285 }286 }287}288289fn expr(p: &mut Parser) -> CompletedMarker {290 match expr_binding_power(p, 0) {291 Ok(m) => m,292 Err(m) => m,293 }294}295fn expr_binding_power(296 p: &mut Parser,297 minimum_binding_power: u8,298) -> Result<CompletedMarker, CompletedMarker> {299 let mut lhs = lhs(p)?;300301 while let Some(op) = BinaryOperatorKind::cast(p.current())302 .or_else(|| p.at(T!['{']).then_some(BinaryOperatorKind::MetaObjectApply))303 {304 let (left_binding_power, right_binding_power) = op.binding_power();305 if left_binding_power < minimum_binding_power {306 break;307 }308309 310 if op != BinaryOperatorKind::MetaObjectApply {311 p.bump();312 }313314 let m = lhs.wrap(p, LHS_EXPR).precede(p);315 let parsed_rhs = expr_binding_power(p, right_binding_power).is_ok();316 lhs = m.complete(317 p,318 if op == BinaryOperatorKind::MetaObjectApply {319 EXPR_OBJ_EXTEND320 } else {321 EXPR_BINARY322 },323 );324325 if !parsed_rhs {326 break;327 }328 }329 Ok(lhs)330}331332const COMPSPEC: SyntaxKindSet = TS![for if];333fn compspec(p: &mut Parser) -> CompletedMarker {334 assert!(p.at_ts(COMPSPEC));335 if p.at(T![for]) {336 let m = p.start();337 p.bump();338 name(p);339 p.expect(T![in]);340 expr(p);341 m.complete(p, FOR_SPEC)342 } else if p.at(T![if]) {343 let m = p.start();344 p.bump();345 expr(p);346 m.complete(p, IF_SPEC)347 } else {348 unreachable!()349 }350}351352fn comma(p: &mut Parser) -> bool {353 comma_with_alternatives(p, TS![])354}355fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {356 if p.at(T![,]) {357 p.bump();358 true359 } else if p.at_ts(set) {360 let _ex = p.expected_syntax_name("comma");361 p.expect_with_recovery_set(T![,], TS![]);362 true363 } else {364 false365 }366}367368fn field_name(p: &mut Parser) {369 let _e = p.expected_syntax_name("field name");370 let m = p.start();371 if p.at(T!['[']) {372 p.bump();373 expr(p);374 p.expect(T![']']);375 m.complete(p, FIELD_NAME_DYNAMIC);376 } else if p.at(IDENT) {377 name(p);378 m.complete(p, FIELD_NAME_FIXED);379 } else if Text::can_cast(p.current()) {380 text(p);381 m.complete(p, FIELD_NAME_FIXED);382 } else {383 m.forget(p);384 p.error_with_recovery_set(TS![; : :: ::: '(']);385 }386}387fn visibility(p: &mut Parser) {388 if p.at_ts(TS![: :: :::]) {389 p.bump()390 } else {391 p.error_with_recovery_set(TS![=]);392 }393}394fn assertion(p: &mut Parser) {395 let m = p.start();396 p.bump_assert(T![assert]);397 expr(p).wrap(p, LHS_EXPR);398 if p.at(T![:]) {399 p.bump();400 expr(p);401 }402 m.complete(p, ASSERTION);403}404fn object(p: &mut Parser) -> CompletedMarker {405 let m_t = p.start();406 let m = p.start();407 p.bump_assert(T!['{']);408409 let mut elems = 0;410 let mut compspecs = Vec::new();411 let mut asserts = Vec::new();412 loop {413 if p.at(T!['}']) {414 p.bump();415 break;416 }417 if p.at_ts(COMPSPEC) {418 if elems == 0 {419 let m = p.start();420 m.complete_missing(p, ExpectedSyntax::Named("field definition"));421 }422 while p.at_ts(COMPSPEC) {423 compspecs.push(compspec(p));424 }425 if comma_with_alternatives(p, TS![;]) {426 continue;427 }428 p.expect(R_BRACE);429 break;430 }431 let m = p.start();432 if p.at(T![local]) {433 obj_local(p);434 m.complete(p, MEMBER_BIND_STMT);435 } else if p.at(T![assert]) {436 assertion(p);437 asserts.push(m.complete(p, MEMBER_ASSERT_STMT));438 } else {439 field_name(p);440 if p.at(T![+]) {441 p.bump();442 }443 let params = if p.at(T!['(']) {444 params_desc(p);445 visibility(p);446 expr(p);447 true448 } else if p.at_ts(TS![: :: :::]) && p.nth_at(1, T![function]) {449 visibility(p);450 p.bump_assert(T![function]);451 params_desc(p);452 expr(p);453 true454 } else {455 visibility(p);456 expr(p);457 false458 };459 elems += 1;460461 if params {462 m.complete(p, MEMBER_FIELD_METHOD)463 } else {464 m.complete(p, MEMBER_FIELD_NORMAL)465 };466 };467 while p.at_ts(COMPSPEC) {468 compspecs.push(compspec(p));469 }470 if comma_with_alternatives(p, TS![;]) {471 continue;472 }473 p.expect(R_BRACE);474 break;475 }476477 if elems > 1 && !compspecs.is_empty() {478 for errored in compspecs {479 errored.wrap_error(480 p,481 "compspec may only be used if there is only one array element",482 );483 }484 m.complete(p, OBJ_BODY_MEMBER_LIST);485 } else if !compspecs.is_empty() {486 for errored in asserts {487 errored.wrap_error(p, "asserts can't be used in object comprehensions");488 }489 m.complete(p, OBJ_BODY_COMP);490 } else {491 m.complete(p, OBJ_BODY_MEMBER_LIST);492 }493 m_t.complete(p, EXPR_OBJECT)494}495fn param(p: &mut Parser) {496 let m = p.start();497 destruct(p);498 if p.at(T![=]) {499 p.bump();500 expr(p);501 }502 m.complete(p, PARAM);503}504fn params_desc(p: &mut Parser) -> CompletedMarker {505 let m = p.start();506 p.bump_assert(T!['(']);507508 loop {509 if p.at(T![')']) {510 p.bump();511 break;512 }513 param(p);514 if comma(p) {515 continue;516 }517 p.expect(T![')']);518 break;519 }520521 m.complete(p, PARAMS_DESC)522}523fn args_desc(p: &mut Parser) {524 let m = p.start();525 p.bump_assert(T!['(']);526527 let started_named = Cell::new(false);528 let mut unnamed_after_named = Vec::new();529530 loop {531 if p.at(T![')']) {532 break;533 }534535 let m = p.start();536 if p.at(IDENT) && p.nth_at(1, T![=]) {537 name(p);538 p.bump();539 expr(p);540 m.complete(p, ARG);541 started_named.set(true);542 } else {543 expr(p);544 let arg = m.complete(p, ARG);545 if started_named.get() {546 unnamed_after_named.push(arg)547 }548 }549 if comma(p) {550 continue;551 }552 break;553 }554 p.expect(T![')']);555 if p.at(T![tailstrict]) {556 p.bump()557 }558559 for errored in unnamed_after_named {560 errored.wrap_error(p, "can't use positional arguments after named");561 }562563 m.complete(p, ARGS_DESC);564}565566fn array(p: &mut Parser) -> CompletedMarker {567 568 let m = p.start();569 p.bump_assert(T!['[']);570571 let mut compspecs = Vec::new();572 let mut elems = 0;573574 loop {575 if p.at(T![']']) {576 p.bump();577 break;578 }579 if elems != 0 && p.at_ts(COMPSPEC) {580 while p.at_ts(COMPSPEC) {581 compspecs.push(compspec(p));582 }583 if comma(p) {584 continue;585 }586 p.expect(T![']']);587 break;588 }589 elems += 1;590 expr(p);591 while p.at_ts(COMPSPEC) {592 compspecs.push(compspec(p));593 }594 if comma(p) {595 continue;596 }597 p.expect(T![']']);598 break;599 }600601 if elems > 1 && !compspecs.is_empty() {602 for spec in compspecs {603 spec.wrap_error(604 p,605 "compspec may only be used if there is only one array element",606 );607 }608609 m.complete(p, EXPR_ARRAY)610 } else if !compspecs.is_empty() {611 m.complete(p, EXPR_ARRAY_COMP)612 } else {613 m.complete(p, EXPR_ARRAY)614 }615}616617#[must_use]618fn slice_desc_or_index(p: &mut Parser) -> bool {619 let m = p.start();620 p.bump();621 622 623 if !p.at(T![:]) && !p.at(T![::]) {624 expr(p);625 }626 if p.at(T![:]) {627 p.bump();628 629 if !p.at(T![']']) {630 expr(p).wrap(p, SLICE_DESC_END);631 }632 if p.at(T![:]) {633 p.bump();634 635 if !p.at(T![']']) {636 expr(p).wrap(p, SLICE_DESC_STEP);637 }638 }639 } else if p.at(T![::]) {640 p.bump();641 642 if !p.at(T![']']) {643 expr(p).wrap(p, SLICE_DESC_END);644 }645 } else {646 647 p.expect(T![']']);648 m.forget(p);649 return false;650 }651 p.expect(T![']']);652 m.complete(p, SLICE_DESC);653 true654}655fn lhs(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {656 let mut lhs = lhs_basic(p)?;657658 loop {659 if p.at(T![.]) {660 let m = lhs.precede(p);661 p.bump();662 name(p);663 lhs = m.complete(p, EXPR_INDEX);664 } else if p.at(T!['[']) {665 if slice_desc_or_index(p) {666 lhs = lhs.precede(p).complete(p, EXPR_SLICE);667 } else {668 lhs = lhs669 .wrap(p, LHS_EXPR)670 .precede(p)671 .complete(p, EXPR_INDEX_EXPR);672 }673 } else if p.at(T!['(']) {674 let m = lhs.precede(p);675 args_desc(p);676 lhs = m.complete(p, EXPR_APPLY);677 } else {678 break;679 }680 }681682 Ok(lhs)683}684fn name(p: &mut Parser) {685 let m = p.start();686 p.expect(IDENT);687 m.complete(p, NAME);688}689fn destruct_rest(p: &mut Parser) {690 let m = p.start();691 p.bump_assert(T![...]);692 if p.at(IDENT) {693 p.bump()694 }695 m.complete(p, DESTRUCT_REST);696}697fn destruct_object_field(p: &mut Parser) {698 let m = p.start();699 name(p);700 if p.at(T![:]) {701 p.bump();702 destruct(p);703 };704 if p.at(T![=]) {705 p.bump();706 expr(p);707 }708 m.complete(p, DESTRUCT_OBJECT_FIELD);709}710fn obj_local(p: &mut Parser) {711 let m = p.start();712 p.bump_assert(T![local]);713 bind(p);714 m.complete(p, OBJ_LOCAL);715}716fn destruct(p: &mut Parser) -> CompletedMarker {717 let m = p.start();718 let _ex = p.expected_syntax_name("destruction specifier");719 if p.at(T![?]) {720 p.bump();721 m.complete(p, DESTRUCT_SKIP)722 } else if p.at(T!['[']) {723 p.bump();724 let mut had_rest = false;725 loop {726 if p.at(T![']']) {727 p.bump();728 break;729 } else if p.at(T![...]) {730 let m_err = p.start_ranger();731 destruct_rest(p);732 733 734 735 had_rest = true;736 } else {737 destruct(p);738 }739 if p.at(T![,]) {740 p.bump();741 continue;742 }743 p.expect(T![']']);744 break;745 }746 m.complete(p, DESTRUCT_ARRAY)747 } else if p.at(T!['{']) {748 p.bump();749 let mut had_rest = false;750 loop {751 if p.at(T!['}']) {752 p.bump();753 break;754 } else if p.at(T![...]) {755 let m_err = p.start_ranger();756 destruct_rest(p);757 758 759 760 had_rest = true;761 } else {762 if had_rest {763 p.error_with_recovery_set(TS![]);764 }765 destruct_object_field(p);766 }767 if p.at(T![,]) {768 p.bump();769 continue;770 }771 p.expect(T!['}']);772 break;773 }774 m.complete(p, DESTRUCT_OBJECT)775 } else if p.at(IDENT) {776 name(p);777 m.complete(p, DESTRUCT_FULL)778 } else {779 m.forget(p);780 p.error_with_recovery_set(TS![; , '}', '(', :])781 }782}783fn bind(p: &mut Parser) {784 let m = p.start();785 if p.at(IDENT) && p.nth_at(1, T!['(']) {786 name(p);787 params_desc(p);788 p.expect(T![=]);789 expr(p);790 m.complete(p, BIND_FUNCTION)791 } else if p.at(IDENT) && p.nth_at(1, T![=]) && p.nth_at(2, T![function]) {792 name(p);793 p.expect(T![=]);794 p.expect(T![function]);795 params_desc(p);796 expr(p);797 m.complete(p, BIND_FUNCTION)798 } else {799 destruct(p);800 p.expect(T![=]);801 expr(p);802 m.complete(p, BIND_DESTRUCT)803 };804}805fn text(p: &mut Parser) {806 assert!(Text::can_cast(p.current()));807 p.bump();808}809fn number(p: &mut Parser) {810 assert!(Number::can_cast(p.current()));811 p.bump();812}813fn literal(p: &mut Parser) {814 assert!(Literal::can_cast(p.current()));815 p.bump();816}817fn lhs_basic(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {818 let _e = p.expected_syntax_name("expression");819 Ok(if Literal::can_cast(p.current()) {820 let m = p.start();821 literal(p);822 m.complete(p, EXPR_LITERAL)823 } else if Text::can_cast(p.current()) {824 let m = p.start();825 text(p);826 m.complete(p, EXPR_STRING)827 } else if Number::can_cast(p.current()) {828 let m = p.start();829 number(p);830 m.complete(p, EXPR_NUMBER)831 } else if p.at(IDENT) {832 let m = p.start();833 name(p);834 m.complete(p, EXPR_VAR)835 } else if p.at(INTRINSIC_THIS_FILE) {836 let m = p.start();837 p.bump();838 m.complete(p, EXPR_INTRINSIC_THIS_FILE)839 } else if p.at(INTRINSIC_ID) {840 let m = p.start();841 p.bump();842 m.complete(p, EXPR_INTRINSIC_ID)843 } else if p.at(INTRINSIC) {844 let m = p.start();845 p.bump();846 p.expect(T!['(']);847 name(p);848 p.expect(T![')']);849 m.complete(p, EXPR_INTRINSIC)850 } else if p.at(T![if]) {851 let m = p.start();852 p.bump();853 expr(p);854 p.expect(T![then]);855 expr(p).wrap(p, TRUE_EXPR);856 if p.at(T![else]) {857 p.bump();858 expr(p).wrap(p, FALSE_EXPR);859 }860 m.complete(p, EXPR_IF_THEN_ELSE)861 } else if p.at(T!['[']) {862 array(p)863 } else if p.at(T!['{']) {864 object(p)865 } else if p.at(T![local]) {866 let m = p.start();867 p.bump();868 loop {869 if p.at(T![;]) {870 p.bump();871 break;872 }873 bind(p);874875 if p.at(T![,]) {876 p.bump();877 continue;878 }879 p.expect(T![;]);880 break;881 }882 expr(p);883 m.complete(p, EXPR_LOCAL)884 } else if p.at(T![function]) {885 let m = p.start();886 p.bump();887 params_desc(p);888 expr(p);889 m.complete(p, EXPR_FUNCTION)890 } else if p.at(T![error]) {891 let m = p.start();892 p.bump();893 expr(p);894 m.complete(p, EXPR_ERROR)895 } else if p.at(T![assert]) {896 let m = p.start();897 assertion(p);898 p.expect(T![;]);899 expr(p);900 m.complete(p, EXPR_ASSERT)901 } else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {902 let m = p.start();903 p.bump();904 text(p);905 m.complete(p, EXPR_IMPORT)906 } else if let Some(op) = UnaryOperatorKind::cast(p.current()) {907 let ((), right_binding_power) = op.binding_power();908909 let m = p.start();910 p.bump();911 let _ = expr_binding_power(p, right_binding_power);912 m.complete(p, EXPR_UNARY)913 } else if p.at(T!['(']) {914 let m = p.start();915 p.bump();916 expr(p);917 p.expect(T![')']);918 m.complete(p, EXPR_PARENED)919 } else {920 return Err(p.error_with_no_skip());921 })922}923924impl Parse {925 pub fn syntax(&self) -> SyntaxNode {926 SyntaxNode::new_root(self.green_node.clone())927 }928}