impl loop parsing for Declaration

Author: Nikita-str

core/parser/src/parser/parse_loop.rs

@@ -1,3 +1,4 @@
+use boa_ast::declaration::LexicalDeclaration;
 use boa_ast::Position;
 use boa_interner::Interner;
 
@@ -32,6 +33,13 @@ macro_rules! parse_cmd {
         ret
     }};
 
+    // or move into `peek_node!`
+    [[PEEK NODE]: $state:ident match $($variants:ident)+] => {{
+        if !matches!($state.peek_node(), Some($(| $crate::parser::ParsedNode::$variants(_))+)) {
+            return Err($state.general_error(concat!("expect `", $(stringify!($variants), "` | `",)+ "` node")))
+        }
+    }};
+
     // or move into `sub_parse!`
     [[SUB PARSE]: $item:expr; $state:ident <= $local:ident as $variant:ident ($point:literal)] => {{
         $state.push_local($crate::parser::SavedState::$variant($local));
@@ -123,8 +131,8 @@ where R: ReadChar,
 pub(super) struct ParseState<'a, R> {
     nodes: Vec<ParsedNode>,
     saved_state: Vec<SavedState>,
-    cursor: &'a mut Cursor<R>,
-    interner: &'a mut Interner,
+    pub cursor: &'a mut Cursor<R>,
+    pub interner: &'a mut Interner,
 }
 impl<'a, R: ReadChar> ParseState<'a, R> {
     pub(super) fn new(cursor: &'a mut Cursor<R>, interner: &'a mut Interner) -> Self {
@@ -162,6 +170,9 @@ impl<'a, R: ReadChar> ParseState<'a, R> {
     pub(super) fn pop_node(&mut self) -> ParseResult<ParsedNode> {
         self.nodes.pop().ok_or_else(||self.general_error("expect parsed node"))
     }
+    pub(super) fn peek_node(&mut self) -> Option<&ParsedNode> {
+        self.nodes.last()
+    }
 
     pub(super) fn pop_local_state(&mut self) -> ParseResult<SavedState> {
         self.saved_state.pop().ok_or_else(||self.general_error("expect saved state"))

core/parser/src/parser/statement/declaration/hoistable/mod.rs

@@ -27,6 +27,7 @@ use crate::{
     source::ReadChar,
     Error,
 };
+use crate::{parse_cmd, parser::{ControlFlow, TokenLoopParser, parse_loop::ParseState}};
 use boa_ast::{
     self as ast,
     expression::Identifier,
@@ -125,6 +126,14 @@ where
     }
 }
 
+impl<R: ReadChar> TokenLoopParser<R> for HoistableDeclaration {
+    fn parse_loop(&mut self, state: &mut ParseState<'_, R>, _continue_point: usize) -> ParseResult<ControlFlow<R>> {
+        let (cursor, interner) = state.mut_inner();
+        let ok = self.parse(cursor, interner)?;
+        parse_cmd!([DONE]: state <= Declaration(ok))
+    }
+}
+
 trait CallableDeclaration {
     fn error_context(&self) -> &'static str;
     fn is_default(&self) -> bool;

core/parser/src/parser/statement/declaration/lexical.rs

@@ -18,6 +18,7 @@ use crate::{
     source::ReadChar,
     Error,
 };
+use crate::{parse_cmd, parser::{ControlFlow, TokenLoopParser, parse_loop::ParseState}};
 use ast::operations::bound_names;
 use boa_ast::{self as ast, declaration::Variable, Keyword, Punctuator};
 use boa_interner::{Interner, Sym};
@@ -121,6 +122,14 @@ where
     }
 }
 
+impl<R: ReadChar> TokenLoopParser<R> for LexicalDeclaration {
+    fn parse_loop(&mut self, state: &mut ParseState<'_, R>, _continue_point: usize) -> ParseResult<ControlFlow<R>> {
+        let (cursor, interner) = state.mut_inner();
+        let ok = self.parse(cursor, interner)?;
+        parse_cmd!([DONE]: state <= Declaration(ok.into()))
+    }
+}
+
 /// Check if the given token is valid after the `let` keyword of a lexical declaration.
 pub(crate) fn allowed_token_after_let(token: Option<&Token>) -> bool {
     matches!(

core/parser/src/parser/statement/declaration/mod.rs

@@ -91,10 +91,39 @@ where
 }
 
 impl<R: ReadChar> TokenLoopParser<R> for Declaration {
-    fn parse_loop(&mut self, state: &mut ParseState<'_, R>, _continue_point: usize) -> ParseResult<ControlFlow<R>> {
-        let (cursor, interner) = state.mut_inner();
-        let ok = self.parse(cursor, interner)?;
-        parse_cmd!([DONE]: state <= Declaration(ok))
+    fn parse_loop(&mut self, state: &mut ParseState<'_, R>, continue_point: usize) -> ParseResult<ControlFlow<R>> {
+        if continue_point == 1 {
+            parse_cmd![[POP LOCAL]: state => Empty];
+            parse_cmd![[PEEK NODE]: state match Declaration]; // pass value up
+            return Ok(ControlFlow::Done)
+        } else if continue_point > 1 {
+            return state.continue_point_error(continue_point)
+        }
+
+        let tok = state.cursor.peek(0, state.interner).or_abrupt()?;
+
+        match tok.kind() {
+            TokenKind::Keyword((Keyword::Function | Keyword::Async | Keyword::Class, _)) => {
+                let node = HoistableDeclaration::new(self.allow_yield, self.allow_await, false);
+                parse_cmd![[SUB PARSE]: node; state <= Empty (1)];
+            }
+            TokenKind::Keyword((Keyword::Const | Keyword::Let, _)) => {
+                let node = LexicalDeclaration::new(true, self.allow_yield, self.allow_await, false);
+                parse_cmd![[SUB PARSE]: node; state <= Empty (1)];
+            }
+            _ => return Err(Error::expected(
+                [
+                    Keyword::Function.to_string(),
+                    Keyword::Async.to_string(),
+                    Keyword::Class.to_string(),
+                    Keyword::Const.to_string(),
+                    Keyword::Let.to_string(),
+                ],
+                tok.to_string(state.interner),
+                tok.span(),
+                "export declaration",
+            )),
+        }
     }
 }
 

core/parser/src/parser/statement/mod.rs

@@ -410,10 +410,6 @@ impl StatementListLocal {
             strict: stmt_list.strict,
         }
     }
-
-    pub(super) fn new_point_list_item<R: ReadChar>(state: &mut ParseState<'_, R>) -> ParseResult<Self> {
-        return Ok(parse_cmd![[POP LOCAL]: state => StatementList])
-    }
 }
 
 impl<R> TokenLoopParser<R> for StatementList
@@ -424,7 +420,7 @@ where
         let mut local = match continue_point {
             0 => StatementListLocal::new(&self, state),
             1 => {
-                let mut local = StatementListLocal::new_point_list_item(state)?;
+                let mut local = parse_cmd![[POP LOCAL]: state => StatementList];
                 Self::continue_point_list_item(&mut local, state)?;
                 local
             }