1use std::{cell::Cell, fmt, rc::Rc};23use rowan::{GreenNode, TextRange};45use crate::{6 AstToken, SyntaxKind,7 SyntaxKind::*,8 SyntaxNode, T, TS,9 event::Event,10 marker::{CompletedMarker, Marker},11 nodes::{BinaryOperatorKind, Literal, Number, Text, UnaryOperatorKind},12 token_set::SyntaxKindSet,13};1415pub struct Parse {16 pub green_node: GreenNode,17 pub errors: Vec<LocatedSyntaxError>,18}1920pub struct Parser {21 22 kinds: Vec<SyntaxKind>,23 pub offset: usize,24 pub events: Vec<Event>,25 pub entered: u32,26 pub hints: Vec<(u32, TextRange, String)>,27 pub last_error_token: usize,28 expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,29 steps: Cell<u64>,30}3132#[derive(Clone, Debug)]33pub enum SyntaxError {34 Unexpected {35 expected: ExpectedSyntax,36 found: SyntaxKind,37 },38 Missing {39 expected: ExpectedSyntax,40 },41 Custom {42 error: String,43 },44 Hint {45 error: String,46 },47}48impl fmt::Display for SyntaxError {49 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {50 match self {51 SyntaxError::Unexpected { expected, found } => {52 write!(f, "unexpected {found:?}, expecting {expected}")53 }54 SyntaxError::Missing { expected } => write!(f, "missing {expected}"),55 SyntaxError::Custom { error } | SyntaxError::Hint { error } => write!(f, "{error}"),56 }57 }58}5960#[derive(Debug)]61pub struct LocatedSyntaxError {62 pub error: SyntaxError,63 pub range: TextRange,64}6566impl Parser {67 pub fn new(kinds: Vec<SyntaxKind>) -> Self {68 Self {69 kinds,70 offset: 0,71 events: vec![],72 entered: 0,73 last_error_token: 0,74 hints: vec![],75 expected_syntax_tracking_state: Rc::new(Cell::new(ExpectedSyntax::Unnamed(TS![]))),76 steps: Cell::new(0),77 }78 }79 pub fn clear_outdated_hints(&mut self) {80 let amount = self81 .hints82 .iter()83 .rev()84 .take_while(|h| h.0 > self.entered)85 .count();86 self.hints.truncate(self.hints.len() - amount);87 }88 fn clear_expected_syntaxes(&self) {89 self.expected_syntax_tracking_state90 .set(ExpectedSyntax::Unnamed(TS![]));91 }92 pub fn start(&mut self) -> Marker {93 let start_event_idx = self.events.len();94 self.events.push(Event::Pending);95 self.entered += 1;96 Marker::new(start_event_idx)97 }98 99 100 101 102 pub fn parse(mut self) -> Vec<Event> {103 let m = self.start();104 expr(&mut self);105 if !self.at(EOF) {106 let m = self.start();107 while !self.at(EOF) {108 self.bump();109 }110 m.complete_error(&mut self, "unexpected tokens after end");111 }112 m.complete(&mut self, SOURCE_FILE);113114 self.events115 }116117 pub(crate) fn expect(&mut self, kind: SyntaxKind) {118 self.expect_with_recovery_set(kind, TS![]);119 }120121 pub(crate) fn expect_with_recovery_set(122 &mut self,123 kind: SyntaxKind,124 recovery_set: SyntaxKindSet,125 ) {126 if self.at(kind) {127 if kind != EOF {128 self.bump();129 }130 } else {131 self.error_with_recovery_set(recovery_set);132 }133 }134135 136 137 138 139 140 141 142 pub fn error_with_no_skip(&mut self) -> CompletedMarker {143 self.error_with_recovery_set(SyntaxKindSet::ALL)144 }145146 pub fn error_with_recovery_set(&mut self, recovery_set: SyntaxKindSet) -> CompletedMarker {147 let expected = self.expected_syntax_tracking_state.get();148 self.expected_syntax_tracking_state149 .set(ExpectedSyntax::Unnamed(TS![]));150151 if self.at_end() || self.at_ts(recovery_set) {152 let m = self.start();153 return m.complete_missing(self, expected);154 }155156 let current_token = self.current();157158 self.last_error_token = self.offset;159160 let m = self.start();161 self.bump();162 let m = m.complete_unexpected(self, expected, current_token);163 self.clear_expected_syntaxes();164 m165 }166 fn bump_assert(&mut self, kind: SyntaxKind) {167 assert!(self.at(kind), "expected {kind:?}");168 self.bump_remap(self.current());169 }170 fn bump(&mut self) {171 self.bump_remap(self.current());172 }173 fn bump_remap(&mut self, kind: SyntaxKind) {174 assert_ne!(self.offset, self.kinds.len(), "already at end");175 self.events.push(Event::Token { kind });176 self.offset += 1;177 self.clear_expected_syntaxes();178 }179 fn step(&self) {180 use std::fmt::Write;181 let steps = self.steps.get();182 if steps >= 15_000_000 {183 let mut out = "seems like parsing is stuck".to_owned();184 {185 let last = 20;186 write!(out, "\n\nLast {last} events:").unwrap();187 for (i, event) in self188 .events189 .iter()190 .skip(self.events.len().saturating_sub(last))191 .enumerate()192 {193 write!(out, "\n{i}. {event:?}").unwrap();194 }195 }196 {197 let next = 20;198 write!(out, "\n\nNext {next} tokens:").unwrap();199 for (i, tok) in self.kinds.iter().skip(self.offset).take(next).enumerate() {200 write!(out, "\n{i}. {tok:?}").unwrap();201 }202 }203 panic!("{out}")204 }205 self.steps.set(steps + 1);206 }207 fn nth(&self, i: usize) -> SyntaxKind {208 self.step();209 let mut offset = self.offset;210 for _ in 0..i {211 offset += 1;212 }213 self.kinds.get(offset).copied().unwrap_or(EOF)214 }215 fn current(&self) -> SyntaxKind {216 self.nth(0)217 }218 #[must_use]219 pub(crate) fn expected_syntax_name(&self, name: &'static str) -> ExpectedSyntaxGuard {220 self.expected_syntax_tracking_state221 .set(ExpectedSyntax::Named(name));222223 ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))224 }225 pub fn at(&self, kind: SyntaxKind) -> bool {226 self.nth_at(0, kind)227 }228 pub fn nth_at(&self, n: usize, kind: SyntaxKind) -> bool {229 if n == 0 {230 if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {231 let kinds = kinds.with(kind);232 self.expected_syntax_tracking_state233 .set(ExpectedSyntax::Unnamed(kinds));234 }235 }236 self.nth(n) == kind237 }238 pub fn at_ts(&self, set: SyntaxKindSet) -> bool {239 if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {240 let kinds = kinds.union(set);241 self.expected_syntax_tracking_state242 .set(ExpectedSyntax::Unnamed(kinds));243 }244 set.contains(self.current())245 }246 pub fn at_end(&self) -> bool {247 self.at(EOF)248 }249}250pub struct ExpectedSyntaxGuard {251 expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,252}253254impl ExpectedSyntaxGuard {255 fn new(expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>) -> Self {256 Self {257 expected_syntax_tracking_state,258 }259 }260}261262impl Drop for ExpectedSyntaxGuard {263 fn drop(&mut self) {264 self.expected_syntax_tracking_state265 .set(ExpectedSyntax::Unnamed(TS![]));266 }267}268269#[derive(Clone, Debug, Copy)]270pub enum ExpectedSyntax {271 Named(&'static str),272 Unnamed(SyntaxKindSet),273}274impl fmt::Display for ExpectedSyntax {275 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {276 match self {277 Self::Named(name) => write!(f, "{name}"),278 Self::Unnamed(set) => write!(f, "{set}"),279 }280 }281}282283fn expr(p: &mut Parser) -> CompletedMarker {284 let m = p.start();285 while p.at(T![local]) || p.at(T![assert]) {286 let m = p.start();287288 if p.at(T![local]) {289 p.bump();290 loop {291 if p.at(T![;]) {292 p.bump();293 break;294 }295 bind(p);296297 if p.at(T![,]) {298 p.bump();299 continue;300 }301 p.expect(T![;]);302 break;303 }304 m.complete(p, STMT_LOCAL);305 } else {306 assertion(p);307 p.expect(T![;]);308 m.complete(p, STMT_ASSERT);309 }310 }311 match expr_binding_power(p, 0) {312 Ok(m) | Err(m) => m,313 };314 m.complete(p, EXPR)315}316317fn expr_binding_power(318 p: &mut Parser,319 minimum_binding_power: u8,320) -> Result<CompletedMarker, CompletedMarker> {321 let mut lhs = lhs(p)?;322323 while let Some(op) = BinaryOperatorKind::cast(p.current())324 .or_else(|| p.at(T!['{']).then_some(BinaryOperatorKind::MetaObjectApply))325 {326 let (left_binding_power, right_binding_power) = op.binding_power();327 if left_binding_power < minimum_binding_power {328 break;329 }330331 let m = lhs.wrap(p, EXPR, false);332333 334 if op != BinaryOperatorKind::MetaObjectApply {335 p.bump();336 }337338 let m = m.precede(p);339 let parsed_rhs = if p.at(T![local]) || p.at(T![assert]) {340 expr(p);341 true342 } else {343 expr_binding_power(p, right_binding_power)344 .map(|v| v.precede(p).complete(p, EXPR))345 .is_ok()346 };347 lhs = m.complete(348 p,349 if op == BinaryOperatorKind::MetaObjectApply {350 EXPR_OBJ_EXTEND351 } else {352 EXPR_BINARY353 },354 );355356 if !parsed_rhs {357 break;358 }359 }360 Ok(lhs)361}362363const COMPSPEC: SyntaxKindSet = TS![for if];364fn compspec(p: &mut Parser) -> CompletedMarker {365 assert!(p.at_ts(COMPSPEC));366 if p.at(T![for]) {367 if p.nth_at(1, T!['[']) && p.nth_at(2, IDENT) && p.nth_at(3, T![']']) && p.nth_at(4, T![:])368 {369 let m = p.start();370 p.bump_assert(T![for]);371 p.bump_assert(T!['[']);372 name(p);373 p.expect(T![']']);374 visibility(p);375 destruct(p);376 p.expect(T![in]);377 expr(p);378 return m.complete(p, FOR_OBJ_SPEC);379 }380 let m = p.start();381 p.bump();382 destruct(p);383 p.expect(T![in]);384 expr(p);385 m.complete(p, FOR_SPEC)386 } else if p.at(T![if]) {387 let m = p.start();388 p.bump();389 expr(p);390 m.complete(p, IF_SPEC)391 } else {392 unreachable!()393 }394}395396fn comma(p: &mut Parser) -> bool {397 comma_with_alternatives(p, TS![])398}399fn comma_with_alternatives(p: &mut Parser, set: SyntaxKindSet) -> bool {400 if p.at(T![,]) {401 p.bump();402 true403 } else if p.at_ts(set) {404 let _ex = p.expected_syntax_name("comma");405 p.expect_with_recovery_set(T![,], TS![]);406 true407 } else {408 false409 }410}411412fn field_name(p: &mut Parser) {413 let _e = p.expected_syntax_name("field name");414 let m = p.start();415 if p.at(T!['[']) {416 p.bump();417 expr(p);418 p.expect(T![']']);419 m.complete(p, FIELD_NAME_DYNAMIC);420 } else if p.at(IDENT) {421 name(p);422 m.complete(p, FIELD_NAME_FIXED);423 } else if Text::can_cast(p.current()) {424 text(p);425 m.complete(p, FIELD_NAME_FIXED);426 } else {427 m.forget(p);428 429 p.error_with_recovery_set(TS![; : '(']);430 }431}432fn visibility(p: &mut Parser) {433 let m = p.start();434 if !p.at_ts(TS![:]) {435 p.error_with_recovery_set(TS![=]);436 }437 p.bump();438 'colons: {439 if !p.at_ts(TS![:]) {440 break 'colons;441 }442 p.bump();443 if !p.at_ts(TS![:]) {444 break 'colons;445 }446 p.bump();447 }448 m.complete(p, VISIBILITY);449}450fn assertion(p: &mut Parser) {451 let m = p.start();452 p.bump_assert(T![assert]);453 expr(p);454 if p.at(T![:]) {455 p.bump();456 expr(p);457 }458 m.complete(p, ASSERTION);459}460fn object(p: &mut Parser) -> CompletedMarker {461 let m_t = p.start();462 let m = p.start();463 p.bump_assert(T!['{']);464465 let mut elems = 0;466 let mut compspecs = Vec::new();467 let mut asserts = Vec::new();468 loop {469 if p.at(T!['}']) {470 p.bump();471 break;472 }473 if p.at_ts(TS![for]) {474 if elems == 0 {475 let m = p.start();476 m.complete_missing(p, ExpectedSyntax::Named("field definition"));477 }478 while p.at_ts(COMPSPEC) {479 compspecs.push(compspec(p));480 }481 if comma_with_alternatives(p, TS![;]) {482 continue;483 }484 p.expect(R_BRACE);485 break;486 }487 let m = p.start();488 if p.at(T![local]) {489 obj_local(p);490 m.complete(p, MEMBER_BIND_STMT);491 } else if p.at(T![assert]) {492 assertion(p);493 asserts.push(m.complete(p, MEMBER_ASSERT_STMT));494 } else {495 field_name(p);496 if p.at(T![+]) {497 p.bump();498 }499 let params = if p.at(T!['(']) {500 params_desc(p);501 visibility(p);502 expr(p);503 true504 } else {505 visibility(p);506 if p.at(T![function]) {507 p.bump_assert(T![function]);508 params_desc(p);509 expr(p);510 true511 } else {512 expr(p);513 false514 }515 };516 elems += 1;517518 if params {519 m.complete(p, MEMBER_FIELD_METHOD)520 } else {521 m.complete(p, MEMBER_FIELD_NORMAL)522 };523 }524 while p.at_ts(COMPSPEC) {525 compspecs.push(compspec(p));526 }527 if comma_with_alternatives(p, TS![;]) {528 continue;529 }530 p.expect(R_BRACE);531 break;532 }533534 if elems > 1 && !compspecs.is_empty() {535 for errored in compspecs {536 errored.wrap_error(537 p,538 "compspec may only be used if there is only one object element",539 true,540 );541 }542 m.complete(p, OBJ_BODY_MEMBER_LIST);543 } else if !compspecs.is_empty() {544 for errored in asserts {545 errored.wrap_error(p, "asserts can't be used in object comprehensions", true);546 }547 m.complete(p, OBJ_BODY_COMP);548 } else {549 m.complete(p, OBJ_BODY_MEMBER_LIST);550 }551 m_t.complete(p, EXPR_OBJECT)552}553fn param(p: &mut Parser) {554 let m = p.start();555 destruct(p);556 if p.at(T![=]) {557 p.bump();558 expr(p);559 }560 m.complete(p, PARAM);561}562fn params_desc(p: &mut Parser) -> CompletedMarker {563 let m = p.start();564 p.bump_assert(T!['(']);565566 loop {567 if p.at(T![')']) {568 p.bump();569 break;570 }571 param(p);572 if comma(p) {573 continue;574 }575 p.expect(T![')']);576 break;577 }578579 m.complete(p, PARAMS_DESC)580}581fn args_desc(p: &mut Parser) {582 let m = p.start();583 p.bump_assert(T!['(']);584585 let started_named = Cell::new(false);586 let mut unnamed_after_named = Vec::new();587588 loop {589 if p.at(T![')']) {590 break;591 }592593 let m = p.start();594 if p.at(IDENT) && p.nth_at(1, T![=]) {595 name(p);596 p.bump();597 expr(p);598 m.complete(p, ARG);599 started_named.set(true);600 } else {601 expr(p);602 let arg = m.complete(p, ARG);603 if started_named.get() {604 unnamed_after_named.push(arg);605 }606 }607 if comma(p) {608 continue;609 }610 break;611 }612 p.expect(T![')']);613 if p.at(T![tailstrict]) {614 p.bump();615 }616617 for errored in unnamed_after_named {618 errored.wrap_error(p, "can't use positional arguments after named", true);619 }620621 m.complete(p, ARGS_DESC);622}623624fn array(p: &mut Parser) -> CompletedMarker {625 626 let m = p.start();627 p.bump_assert(T!['[']);628629 let mut compspecs = Vec::new();630 let mut elems = 0;631632 loop {633 if p.at(T![']']) {634 p.bump();635 break;636 }637 if elems != 0 && p.at_ts(TS![for]) {638 while p.at_ts(COMPSPEC) {639 compspecs.push(compspec(p));640 }641 if comma(p) {642 continue;643 }644 p.expect(T![']']);645 break;646 }647 expr(p);648 elems += 1;649 while p.at_ts(COMPSPEC) {650 compspecs.push(compspec(p));651 }652 if comma(p) {653 continue;654 }655 p.expect(T![']']);656 break;657 }658659 if elems > 1 && !compspecs.is_empty() {660 for spec in compspecs {661 spec.wrap_error(662 p,663 "compspec may only be used if there is only one array element",664 true,665 );666 }667668 m.complete(p, EXPR_ARRAY)669 } else if !compspecs.is_empty() {670 m.complete(p, EXPR_ARRAY_COMP)671 } else {672 m.complete(p, EXPR_ARRAY)673 }674}675676#[must_use]677fn slice_desc_or_index(p: &mut Parser) -> bool {678 let m = p.start();679 p.bump();680 681 if !p.at(T![:]) {682 expr(p);683 }684 if p.at(T![:]) {685 p.bump();686 687 if !p.at_ts(TS![']' :]) {688 expr(p).wrap(p, SLICE_DESC_END, true);689 }690 if p.at(T![:]) {691 p.bump();692 693 if !p.at(T![']']) {694 expr(p).wrap(p, SLICE_DESC_STEP, true);695 }696 }697 } else {698 699 p.expect(T![']']);700 m.forget(p);701 return false;702 }703 p.expect(T![']']);704 m.complete(p, SLICE_DESC);705 true706}707708fn suffix(p: &mut Parser) {709 loop {710 let start = p.start();711 let _marker: CompletedMarker = if p.at(T![?]) {712 p.bump();713 p.expect(T![.]);714 if p.at(IDENT) {715 name(p);716 start.complete(p, SUFFIX_INDEX)717 } else if p.at(T!['[']) {718 p.bump();719 expr(p);720 p.expect(T![']']);721 start.complete(p, SUFFIX_INDEX_EXPR)722 } else {723 start.complete_missing(p, ExpectedSyntax::Named("index"))724 }725 } else if p.at(T![.]) {726 p.bump();727 name(p);728 start.complete(p, SUFFIX_INDEX)729 } else if p.at(T!['[']) {730 if slice_desc_or_index(p) {731 start.complete(p, SUFFIX_SLICE)732 } else {733 start.complete(p, SUFFIX_INDEX_EXPR)734 }735 } else if p.at(T!['(']) {736 args_desc(p);737 start.complete(p, SUFFIX_APPLY)738 } else {739 start.forget(p);740 break;741 };742 }743}744745fn lhs(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {746 let lhs = lhs_basic(p)?;747748 suffix(p);749750 Ok(lhs)751}752fn name(p: &mut Parser) {753 let m = p.start();754 p.expect(IDENT);755 m.complete(p, NAME);756}757fn destruct_rest(p: &mut Parser) {758 let m = p.start();759 p.bump_assert(T![...]);760 if p.at(IDENT) {761 p.bump();762 }763 m.complete(p, DESTRUCT_REST);764}765fn destruct_object_field(p: &mut Parser) {766 let m = p.start();767 name(p);768 if p.at(T![:]) {769 p.bump();770 destruct(p);771 }772 if p.at(T![=]) {773 p.bump();774 expr(p);775 }776 m.complete(p, DESTRUCT_OBJECT_FIELD);777}778fn obj_local(p: &mut Parser) {779 let m = p.start();780 p.bump_assert(T![local]);781 bind(p);782 m.complete(p, OBJ_LOCAL);783}784fn destruct(p: &mut Parser) -> CompletedMarker {785 let m = p.start();786 let _ex = p.expected_syntax_name("destruction specifier");787 if p.at(T![?]) {788 p.bump();789 m.complete(p, DESTRUCT_SKIP)790 } else if p.at(T!['[']) {791 p.bump();792 793 loop {794 if p.at(T![']']) {795 p.bump();796 break;797 } else if p.at(T![...]) {798 799 destruct_rest(p);800 801 802 803 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 824 destruct_rest(p);825 826 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.forget(p);848 p.error_with_recovery_set(TS![; , '}', '(', :])849 }850}851fn bind(p: &mut Parser) {852 let m = p.start();853 if p.at(IDENT) && p.nth_at(1, T!['(']) {854 name(p);855 params_desc(p);856 p.expect(T![=]);857 expr(p);858 m.complete(p, BIND_FUNCTION)859 } else if p.at(IDENT) && p.nth_at(1, T![=]) && p.nth_at(2, T![function]) {860 name(p);861 p.expect(T![=]);862 p.expect(T![function]);863 params_desc(p);864 expr(p);865 m.complete(p, BIND_FUNCTION)866 } else {867 destruct(p);868 p.expect(T![=]);869 expr(p);870 m.complete(p, BIND_DESTRUCT)871 };872}873fn text(p: &mut Parser) {874 assert!(Text::can_cast(p.current()));875 p.bump();876}877fn number(p: &mut Parser) {878 assert!(Number::can_cast(p.current()));879 p.bump();880}881fn literal(p: &mut Parser) {882 assert!(Literal::can_cast(p.current()));883 p.bump();884}885fn lhs_basic(p: &mut Parser) -> Result<CompletedMarker, CompletedMarker> {886 let _e = p.expected_syntax_name("expression");887 Ok(if Literal::can_cast(p.current()) {888 let m = p.start();889 literal(p);890 m.complete(p, EXPR_LITERAL)891 } else if Text::can_cast(p.current()) {892 let m = p.start();893 text(p);894 m.complete(p, EXPR_STRING)895 } else if Number::can_cast(p.current()) {896 let m = p.start();897 number(p);898 m.complete(p, EXPR_NUMBER)899 } else if p.at(IDENT) {900 let m = p.start();901 name(p);902 m.complete(p, EXPR_VAR)903 } else if p.at(T![if]) {904 let m = p.start();905 p.bump();906 expr(p);907 p.expect(T![then]);908 expr(p).wrap(p, TRUE_EXPR, true);909 if p.at(T![else]) {910 p.bump();911 expr(p).wrap(p, FALSE_EXPR, true);912 }913 m.complete(p, EXPR_IF_THEN_ELSE)914 } else if p.at(T!['[']) {915 array(p)916 } else if p.at(T!['{']) {917 object(p)918 } else if p.at(T![function]) {919 let m = p.start();920 p.bump();921 params_desc(p);922 expr(p);923 m.complete(p, EXPR_FUNCTION)924 } else if p.at(T![error]) {925 let m = p.start();926 p.bump();927 expr(p);928 m.complete(p, EXPR_ERROR)929 } else if p.at(T![import]) || p.at(T![importstr]) || p.at(T![importbin]) {930 let m = p.start();931 p.bump();932 text(p);933 m.complete(p, EXPR_IMPORT)934 } else if let Some(op) = UnaryOperatorKind::cast(p.current()) {935 let ((), right_binding_power) = op.binding_power();936937 let m = p.start();938 p.bump();939 let _ = expr_binding_power(p, right_binding_power).map(|v| v.precede(p).complete(p, EXPR));940 m.complete(p, EXPR_UNARY)941 } else if p.at(T!['(']) {942 let m = p.start();943 p.bump();944 expr(p);945 p.expect(T![')']);946 m.complete(p, EXPR_PARENED)947 } else {948 return Err(p.error_with_no_skip());949 })950}951952impl Parse {953 pub fn syntax(&self) -> SyntaxNode {954 SyntaxNode::new_root(self.green_node.clone())955 }956}