mirror of https://github.com/boa-dev/boa.git
Iban Eguia
5 years ago
committed by
GitHub
71 changed files with 6631 additions and 3049 deletions
@ -0,0 +1,106 @@ |
|||||||
|
//! Error and result implementation for the parser.
|
||||||
|
use crate::syntax::ast::{ |
||||||
|
keyword::Keyword, |
||||||
|
node::Node, |
||||||
|
pos::Position, |
||||||
|
token::{Token, TokenKind}, |
||||||
|
}; |
||||||
|
use std::fmt; |
||||||
|
|
||||||
|
/// Result of a parsing operation.
|
||||||
|
pub type ParseResult = Result<Node, ParseError>; |
||||||
|
|
||||||
|
/// `ParseError` is an enum which represents errors encounted during parsing an expression
|
||||||
|
#[derive(Debug, Clone)] |
||||||
|
pub enum ParseError { |
||||||
|
/// When it expected a certain kind of token, but got another as part of something
|
||||||
|
Expected(Vec<TokenKind>, Token, &'static str), |
||||||
|
/// When it expected a certain expression, but got another
|
||||||
|
ExpectedExpr(&'static str, Node, Position), |
||||||
|
/// When it didn't expect this keyword
|
||||||
|
UnexpectedKeyword(Keyword, Position), |
||||||
|
/// When a token is unexpected
|
||||||
|
Unexpected(Token, Option<&'static str>), |
||||||
|
/// When there is an abrupt end to the parsing
|
||||||
|
AbruptEnd, |
||||||
|
/// Out of range error, attempting to set a position where there is no token
|
||||||
|
RangeError, |
||||||
|
/// Catch all General Error
|
||||||
|
General(&'static str, Option<Position>), |
||||||
|
} |
||||||
|
|
||||||
|
impl fmt::Display for ParseError { |
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||||
|
match self { |
||||||
|
Self::Expected(expected, actual, routine) => write!( |
||||||
|
f, |
||||||
|
"Expected {}, got '{}' in {} at line {}, col {}", |
||||||
|
if expected.len() == 1 { |
||||||
|
format!( |
||||||
|
"token '{}'", |
||||||
|
expected.first().map(TokenKind::to_string).unwrap() |
||||||
|
) |
||||||
|
} else { |
||||||
|
format!( |
||||||
|
"one of {}", |
||||||
|
expected |
||||||
|
.iter() |
||||||
|
.enumerate() |
||||||
|
.map(|(i, t)| { |
||||||
|
format!( |
||||||
|
"{}'{}'", |
||||||
|
if i == 0 { |
||||||
|
"" |
||||||
|
} else if i == expected.len() - 1 { |
||||||
|
" or " |
||||||
|
} else { |
||||||
|
", " |
||||||
|
}, |
||||||
|
t |
||||||
|
) |
||||||
|
}) |
||||||
|
.collect::<String>() |
||||||
|
) |
||||||
|
}, |
||||||
|
actual, |
||||||
|
routine, |
||||||
|
actual.pos.line_number, |
||||||
|
actual.pos.column_number |
||||||
|
), |
||||||
|
Self::ExpectedExpr(expected, actual, pos) => write!( |
||||||
|
f, |
||||||
|
"Expected expression '{}', got '{}' at line {}, col {}", |
||||||
|
expected, actual, pos.line_number, pos.column_number |
||||||
|
), |
||||||
|
Self::UnexpectedKeyword(keyword, pos) => write!( |
||||||
|
f, |
||||||
|
"Unexpected keyword: '{}' at line {}, col {}", |
||||||
|
keyword, pos.line_number, pos.column_number |
||||||
|
), |
||||||
|
Self::Unexpected(tok, msg) => write!( |
||||||
|
f, |
||||||
|
"Unexpected Token '{}'{} at line {}, col {}", |
||||||
|
tok, |
||||||
|
if let Some(m) = msg { |
||||||
|
format!(", {}", m) |
||||||
|
} else { |
||||||
|
String::new() |
||||||
|
}, |
||||||
|
tok.pos.line_number, |
||||||
|
tok.pos.column_number |
||||||
|
), |
||||||
|
Self::AbruptEnd => write!(f, "Abrupt End"), |
||||||
|
Self::General(msg, pos) => write!( |
||||||
|
f, |
||||||
|
"{}{}", |
||||||
|
msg, |
||||||
|
if let Some(pos) = pos { |
||||||
|
format!(" at line {}, col {}", pos.line_number, pos.column_number) |
||||||
|
} else { |
||||||
|
String::new() |
||||||
|
} |
||||||
|
), |
||||||
|
Self::RangeError => write!(f, "RangeError!"), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,161 @@ |
|||||||
|
//! Arrow function parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-arrow-function-definitions
|
||||||
|
|
||||||
|
use super::AssignmentExpression; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{ |
||||||
|
node::{FormalParameter, Node}, |
||||||
|
punc::Punctuator, |
||||||
|
token::TokenKind, |
||||||
|
}, |
||||||
|
parser::{ |
||||||
|
function::{FormalParameters, FunctionBody}, |
||||||
|
AllowAwait, AllowIn, AllowYield, Cursor, ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Arrow function parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ArrowFunction
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser) struct ArrowFunction { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ArrowFunction { |
||||||
|
/// Creates a new `ArrowFunction` parser.
|
||||||
|
pub(in crate::syntax::parser) fn new<I, Y, A>( |
||||||
|
allow_in: I, |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ArrowFunction { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let next_token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let params = match &next_token.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||||
|
let params = |
||||||
|
FormalParameters::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::CloseParen, "arrow function")?; |
||||||
|
params |
||||||
|
} |
||||||
|
TokenKind::Identifier(param_name) => vec![FormalParameter { |
||||||
|
init: None, |
||||||
|
name: param_name.clone(), |
||||||
|
is_rest_param: false, |
||||||
|
}], |
||||||
|
_ => { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![ |
||||||
|
TokenKind::Punctuator(Punctuator::OpenParen), |
||||||
|
TokenKind::identifier("identifier"), |
||||||
|
], |
||||||
|
next_token.clone(), |
||||||
|
"arrow function", |
||||||
|
)) |
||||||
|
} |
||||||
|
}; |
||||||
|
cursor.peek_expect_no_lineterminator(0, "arrow function")?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::Arrow, "arrow function")?; |
||||||
|
|
||||||
|
let body = ConciseBody::new(self.allow_in).parse(cursor)?; |
||||||
|
|
||||||
|
Ok(Node::arrow_function_decl(params, body)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <https://tc39.es/ecma262/#prod-ConciseBody>
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct ConciseBody { |
||||||
|
allow_in: AllowIn, |
||||||
|
} |
||||||
|
|
||||||
|
impl ConciseBody { |
||||||
|
/// Creates a new `ConcideBody` parser.
|
||||||
|
fn new<I>(allow_in: I) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ConciseBody { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
match cursor.peek(0).ok_or(ParseError::AbruptEnd)?.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBlock) => { |
||||||
|
let _ = cursor.next(); |
||||||
|
let body = FunctionBody::new(false, false) |
||||||
|
.parse(cursor) |
||||||
|
.map(Node::StatementList)?; |
||||||
|
cursor.expect(Punctuator::CloseBlock, "arrow function")?; |
||||||
|
Ok(body) |
||||||
|
} |
||||||
|
_ => Ok(Node::return_node( |
||||||
|
ExpressionBody::new(self.allow_in, false).parse(cursor)?, |
||||||
|
)), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <https://tc39.es/ecma262/#prod-ExpressionBody>
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct ExpressionBody { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ExpressionBody { |
||||||
|
/// Creates a new `ExpressionBody` parser.
|
||||||
|
fn new<I, A>(allow_in: I, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ExpressionBody { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
AssignmentExpression::new(self.allow_in, false, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,79 @@ |
|||||||
|
//! Conditional operator parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-conditional-operator
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::{AssignmentExpression, LogicalORExpression}, |
||||||
|
AllowAwait, AllowIn, AllowYield, Cursor, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Conditional expression parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ConditionalExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::expression) struct ConditionalExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ConditionalExpression { |
||||||
|
/// Creates a new `ConditionalExpression` parser.
|
||||||
|
pub(in crate::syntax::parser::expression) fn new<I, Y, A>( |
||||||
|
allow_in: I, |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ConditionalExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// TODO: coalesce expression
|
||||||
|
let lhs = LogicalORExpression::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
|
||||||
|
if let Some(tok) = cursor.next() { |
||||||
|
if tok.kind == TokenKind::Punctuator(Punctuator::Question) { |
||||||
|
let then_clause = |
||||||
|
AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::Colon, "conditional expression")?; |
||||||
|
|
||||||
|
let else_clause = |
||||||
|
AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
return Ok(Node::conditional_op(lhs, then_clause, else_clause)); |
||||||
|
} else { |
||||||
|
cursor.back(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,94 @@ |
|||||||
|
//! Exponentiation operator parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-exp-operator
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{ |
||||||
|
keyword::Keyword, |
||||||
|
node::Node, |
||||||
|
op::{BinOp, NumOp}, |
||||||
|
punc::Punctuator, |
||||||
|
token::TokenKind, |
||||||
|
}, |
||||||
|
parser::{ |
||||||
|
expression::{unary::UnaryExpression, update::UpdateExpression}, |
||||||
|
AllowAwait, AllowYield, Cursor, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses an exponentiation expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ExponentiationExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::expression) struct ExponentiationExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ExponentiationExpression { |
||||||
|
/// Creates a new `ExponentiationExpression` parser.
|
||||||
|
pub(in crate::syntax::parser::expression) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl ExponentiationExpression { |
||||||
|
/// Checks by looking at the next token to see whether it's a unary operator or not.
|
||||||
|
fn is_unary_expression(cursor: &mut Cursor<'_>) -> bool { |
||||||
|
if let Some(tok) = cursor.peek(0) { |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::Delete) |
||||||
|
| TokenKind::Keyword(Keyword::Void) |
||||||
|
| TokenKind::Keyword(Keyword::TypeOf) |
||||||
|
| TokenKind::Punctuator(Punctuator::Add) |
||||||
|
| TokenKind::Punctuator(Punctuator::Sub) |
||||||
|
| TokenKind::Punctuator(Punctuator::Not) |
||||||
|
| TokenKind::Punctuator(Punctuator::Neg) => true, |
||||||
|
_ => false, |
||||||
|
} |
||||||
|
} else { |
||||||
|
false |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ExponentiationExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
if Self::is_unary_expression(cursor) { |
||||||
|
return UnaryExpression::new(self.allow_yield, self.allow_await).parse(cursor); |
||||||
|
} |
||||||
|
|
||||||
|
let lhs = UpdateExpression::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
if let Some(tok) = cursor.next() { |
||||||
|
if let TokenKind::Punctuator(Punctuator::Exp) = tok.kind { |
||||||
|
return Ok(Node::bin_op( |
||||||
|
BinOp::Num(NumOp::Exp), |
||||||
|
lhs, |
||||||
|
self.parse(cursor)?, |
||||||
|
)); |
||||||
|
} else { |
||||||
|
cursor.back(); |
||||||
|
} |
||||||
|
} |
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,124 @@ |
|||||||
|
//! Assignment operator parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-assignment-operators
|
||||||
|
|
||||||
|
mod arrow_function; |
||||||
|
mod conditional; |
||||||
|
mod exponentiation; |
||||||
|
|
||||||
|
use self::{arrow_function::ArrowFunction, conditional::ConditionalExpression}; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowIn, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
pub(super) use exponentiation::ExponentiationExpression; |
||||||
|
|
||||||
|
/// Assignment expression parsing.
|
||||||
|
///
|
||||||
|
/// This can be one of the following:
|
||||||
|
///
|
||||||
|
/// - [`ConditionalExpression`](../conditional_operator/struct.ConditionalExpression.html)
|
||||||
|
/// - `YieldExpression`
|
||||||
|
/// - [`ArrowFunction`](../../function/arrow_function/struct.ArrowFunction.html)
|
||||||
|
/// - `AsyncArrowFunction`
|
||||||
|
/// - [`LeftHandSideExpression`][lhs] `=` `AssignmentExpression`
|
||||||
|
/// - [`LeftHandSideExpression`][lhs] `AssignmentOperator` `AssignmentExpression`
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-AssignmentExpression
|
||||||
|
/// [lhs]: ../lhs_expression/struct.LeftHandSideExpression.html
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser) struct AssignmentExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl AssignmentExpression { |
||||||
|
/// Creates a new `AssignmentExpression` parser.
|
||||||
|
pub(in crate::syntax::parser) fn new<I, Y, A>( |
||||||
|
allow_in: I, |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for AssignmentExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// Arrow function
|
||||||
|
let next_token = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
match next_token.kind { |
||||||
|
// a=>{}
|
||||||
|
TokenKind::Identifier(_) |
||||||
|
if cursor |
||||||
|
.peek_expect_no_lineterminator(1, "arrow function") |
||||||
|
.is_ok() => |
||||||
|
{ |
||||||
|
if let Some(tok) = cursor.peek(1) { |
||||||
|
if tok.kind == TokenKind::Punctuator(Punctuator::Arrow) { |
||||||
|
return ArrowFunction::new( |
||||||
|
self.allow_in, |
||||||
|
self.allow_yield, |
||||||
|
self.allow_await, |
||||||
|
) |
||||||
|
.parse(cursor); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
// (a,b)=>{}
|
||||||
|
TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||||
|
if let Some(node) = |
||||||
|
ArrowFunction::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.try_parse(cursor) |
||||||
|
{ |
||||||
|
return Ok(node); |
||||||
|
} |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
let mut lhs = ConditionalExpression::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
// let mut lhs = self.read_block()?;
|
||||||
|
|
||||||
|
if let Some(tok) = cursor.next() { |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::Assign) => { |
||||||
|
lhs = Node::assign(lhs, self.parse(cursor)?) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(p) if p.as_binop().is_some() => { |
||||||
|
let expr = self.parse(cursor)?; |
||||||
|
let binop = p.as_binop().expect("binop disappeared"); |
||||||
|
lhs = Node::bin_op(binop, lhs, expr); |
||||||
|
} |
||||||
|
_ => { |
||||||
|
cursor.back(); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,94 @@ |
|||||||
|
//! Argument parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Glossary/Argument
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#prod-Arguments
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::AssignmentExpression, AllowAwait, AllowYield, Cursor, ParseError, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a list of arguments.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Glossary/Argument
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-Arguments
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::expression) struct Arguments { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl Arguments { |
||||||
|
/// Creates a new `Arguments` parser.
|
||||||
|
pub(in crate::syntax::parser::expression) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for Arguments { |
||||||
|
type Output = Vec<Node>; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Vec<Node>, ParseError> { |
||||||
|
cursor.expect(Punctuator::OpenParen, "arguments")?; |
||||||
|
let mut args = Vec::new(); |
||||||
|
loop { |
||||||
|
let next_token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
match next_token.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::CloseParen) => break, |
||||||
|
TokenKind::Punctuator(Punctuator::Comma) => { |
||||||
|
if args.is_empty() { |
||||||
|
return Err(ParseError::Unexpected(next_token.clone(), None)); |
||||||
|
} |
||||||
|
|
||||||
|
if cursor.next_if(Punctuator::CloseParen).is_some() { |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
_ => { |
||||||
|
if !args.is_empty() { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![ |
||||||
|
TokenKind::Punctuator(Punctuator::Comma), |
||||||
|
TokenKind::Punctuator(Punctuator::CloseParen), |
||||||
|
], |
||||||
|
next_token.clone(), |
||||||
|
"argument list", |
||||||
|
)); |
||||||
|
} else { |
||||||
|
cursor.back(); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if cursor.next_if(Punctuator::Spread).is_some() { |
||||||
|
args.push(Node::spread( |
||||||
|
AssignmentExpression::new(true, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
)); |
||||||
|
} else { |
||||||
|
args.push( |
||||||
|
AssignmentExpression::new(true, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
); |
||||||
|
} |
||||||
|
} |
||||||
|
Ok(args) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,102 @@ |
|||||||
|
//! Call expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#prod-CallExpression
|
||||||
|
|
||||||
|
use super::arguments::Arguments; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::Expression, AllowAwait, AllowYield, Cursor, ParseError, ParseResult, |
||||||
|
TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a call expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-CallExpression
|
||||||
|
#[derive(Debug)] |
||||||
|
pub(super) struct CallExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
first_member_expr: Node, |
||||||
|
} |
||||||
|
|
||||||
|
impl CallExpression { |
||||||
|
/// Creates a new `CallExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A, first_member_expr: Node) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
first_member_expr, |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for CallExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let mut lhs = match cursor.peek(0) { |
||||||
|
Some(tk) if tk.kind == TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||||
|
let args = Arguments::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
Node::call(self.first_member_expr, args) |
||||||
|
} |
||||||
|
_ => { |
||||||
|
let next_token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::Punctuator(Punctuator::OpenParen)], |
||||||
|
next_token.clone(), |
||||||
|
"call expression", |
||||||
|
)); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
while let Some(tok) = cursor.peek(0) { |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||||
|
let args = Arguments::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
lhs = Node::call(lhs, args); |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Dot) => { |
||||||
|
let _ = cursor.next().ok_or(ParseError::AbruptEnd)?; // We move the cursor.
|
||||||
|
match &cursor.next().ok_or(ParseError::AbruptEnd)?.kind { |
||||||
|
TokenKind::Identifier(name) => { |
||||||
|
lhs = Node::get_const_field(lhs, name); |
||||||
|
} |
||||||
|
TokenKind::Keyword(kw) => { |
||||||
|
lhs = Node::get_const_field(lhs, kw.to_string()); |
||||||
|
} |
||||||
|
_ => { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
tok.clone(), |
||||||
|
"call expression", |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBracket) => { |
||||||
|
let _ = cursor.next().ok_or(ParseError::AbruptEnd)?; // We move the cursor.
|
||||||
|
let idx = |
||||||
|
Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::CloseBracket, "call expression")?; |
||||||
|
lhs = Node::get_field(lhs, idx); |
||||||
|
} |
||||||
|
_ => break, |
||||||
|
} |
||||||
|
} |
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,88 @@ |
|||||||
|
//! Member expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#prod-MemberExpression
|
||||||
|
|
||||||
|
use super::arguments::Arguments; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::{primary::PrimaryExpression, Expression}, |
||||||
|
AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a member expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-MemberExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct MemberExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl MemberExpression { |
||||||
|
/// Creates a new `MemberExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for MemberExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let mut lhs = if cursor.peek(0).ok_or(ParseError::AbruptEnd)?.kind |
||||||
|
== TokenKind::Keyword(Keyword::New) |
||||||
|
{ |
||||||
|
let _ = cursor.next().expect("keyword disappeared"); |
||||||
|
let lhs = self.parse(cursor)?; |
||||||
|
let args = Arguments::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
let call_node = Node::call(lhs, args); |
||||||
|
|
||||||
|
Node::new(call_node) |
||||||
|
} else { |
||||||
|
PrimaryExpression::new(self.allow_yield, self.allow_await).parse(cursor)? |
||||||
|
}; |
||||||
|
while let Some(tok) = cursor.peek(0) { |
||||||
|
match &tok.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::Dot) => { |
||||||
|
let _ = cursor.next().ok_or(ParseError::AbruptEnd)?; // We move the cursor forward.
|
||||||
|
match &cursor.next().ok_or(ParseError::AbruptEnd)?.kind { |
||||||
|
TokenKind::Identifier(name) => lhs = Node::get_const_field(lhs, name), |
||||||
|
TokenKind::Keyword(kw) => lhs = Node::get_const_field(lhs, kw.to_string()), |
||||||
|
_ => { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
tok.clone(), |
||||||
|
"member expression", |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBracket) => { |
||||||
|
let _ = cursor.next().ok_or(ParseError::AbruptEnd)?; // We move the cursor forward.
|
||||||
|
let idx = |
||||||
|
Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::CloseBracket, "member expression")?; |
||||||
|
lhs = Node::get_field(lhs, idx); |
||||||
|
} |
||||||
|
_ => break, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,61 @@ |
|||||||
|
//! Left hand side expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Left-hand-side_expressions
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-left-hand-side-expressions
|
||||||
|
|
||||||
|
mod arguments; |
||||||
|
mod call; |
||||||
|
mod member; |
||||||
|
|
||||||
|
use self::{call::CallExpression, member::MemberExpression}; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowYield, Cursor, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a left hand side expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Left-hand-side_expressions
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-LeftHandSideExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct LeftHandSideExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl LeftHandSideExpression { |
||||||
|
/// Creates a new `LeftHandSideExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for LeftHandSideExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// TODO: Implement NewExpression: new MemberExpression
|
||||||
|
let lhs = MemberExpression::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
match cursor.peek(0) { |
||||||
|
Some(ref tok) if tok.kind == TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||||
|
CallExpression::new(self.allow_yield, self.allow_await, lhs).parse(cursor) |
||||||
|
} |
||||||
|
_ => Ok(lhs), // TODO: is this correct?
|
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,479 @@ |
|||||||
|
//! Expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-ecmascript-language-expressions
|
||||||
|
|
||||||
|
mod assignment; |
||||||
|
mod left_hand_side; |
||||||
|
mod primary; |
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
mod unary; |
||||||
|
mod update; |
||||||
|
|
||||||
|
use self::assignment::ExponentiationExpression; |
||||||
|
pub(super) use self::{assignment::AssignmentExpression, primary::Initializer}; |
||||||
|
use super::{AllowAwait, AllowIn, AllowYield, Cursor, ParseResult, TokenParser}; |
||||||
|
use crate::syntax::ast::{node::Node, punc::Punctuator, token::TokenKind}; |
||||||
|
|
||||||
|
/// Generates an expression parser.
|
||||||
|
///
|
||||||
|
/// This macro has 2 mandatory identifiers:
|
||||||
|
/// - The `$name` identifier will contain the name of the parsing structure.
|
||||||
|
/// - The `$lower` identifier will contain the parser for lower level expressions.
|
||||||
|
///
|
||||||
|
/// Those exressions are divided by the punctuators passed as the third parameter.
|
||||||
|
macro_rules! expression { ($name:ident, $lower:ident, [$( $op:path ),*], [$( $low_param:ident ),*] ) => { |
||||||
|
impl TokenParser for $name { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let mut lhs = $lower::new($( self.$low_param ),*).parse(cursor)?; |
||||||
|
while let Some(tok) = cursor.peek(0) { |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Punctuator(op) if $( op == $op )||* => { |
||||||
|
let _ = cursor.next().expect("token disappeared"); |
||||||
|
lhs = Node::bin_op( |
||||||
|
op.as_binop().expect("could not get binary operation"), |
||||||
|
lhs, |
||||||
|
$lower::new($( self.$low_param ),*).parse(cursor)? |
||||||
|
) |
||||||
|
} |
||||||
|
_ => break
|
||||||
|
} |
||||||
|
} |
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
|
} } |
||||||
|
|
||||||
|
/// Expression parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-Expression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct Expression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl Expression { |
||||||
|
/// Creates a new `Expression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
Expression, |
||||||
|
AssignmentExpression, |
||||||
|
[Punctuator::Comma], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a logical `OR` expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR_2
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-LogicalORExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct LogicalORExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl LogicalORExpression { |
||||||
|
/// Creates a new `LogicalORExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
LogicalORExpression, |
||||||
|
LogicalANDExpression, |
||||||
|
[Punctuator::BoolOr], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a logical `AND` expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND_2
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-LogicalANDExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct LogicalANDExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl LogicalANDExpression { |
||||||
|
/// Creates a new `LogicalANDExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
LogicalANDExpression, |
||||||
|
BitwiseORExpression, |
||||||
|
[Punctuator::BoolAnd], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a bitwise `OR` expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_OR
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-BitwiseORExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct BitwiseORExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl BitwiseORExpression { |
||||||
|
/// Creates a new `BitwiseORExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
BitwiseORExpression, |
||||||
|
BitwiseXORExpression, |
||||||
|
[Punctuator::Or], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a bitwise `XOR` expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-BitwiseXORExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct BitwiseXORExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl BitwiseXORExpression { |
||||||
|
/// Creates a new `BitwiseXORExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
BitwiseXORExpression, |
||||||
|
BitwiseANDExpression, |
||||||
|
[Punctuator::Xor], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a bitwise `AND` expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_AND
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-BitwiseANDExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct BitwiseANDExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl BitwiseANDExpression { |
||||||
|
/// Creates a new `BitwiseANDExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
BitwiseANDExpression, |
||||||
|
EqualityExpression, |
||||||
|
[Punctuator::And], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses an equality expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality_operators
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-equality-operators
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct EqualityExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl EqualityExpression { |
||||||
|
/// Creates a new `EqualityExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
EqualityExpression, |
||||||
|
RelationalExpression, |
||||||
|
[ |
||||||
|
Punctuator::Eq, |
||||||
|
Punctuator::NotEq, |
||||||
|
Punctuator::StrictEq, |
||||||
|
Punctuator::StrictNotEq |
||||||
|
], |
||||||
|
[allow_in, allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a relational expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Relational_operators
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-relational-operators
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct RelationalExpression { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl RelationalExpression { |
||||||
|
/// Creates a new `RelationalExpression` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
RelationalExpression, |
||||||
|
ShiftExpression, |
||||||
|
[ |
||||||
|
Punctuator::LessThan, |
||||||
|
Punctuator::GreaterThan, |
||||||
|
Punctuator::LessThanOrEq, |
||||||
|
Punctuator::GreaterThanOrEq |
||||||
|
], |
||||||
|
[allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a bitwise shift expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_shift_operators
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-bitwise-shift-operators
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct ShiftExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ShiftExpression { |
||||||
|
/// Creates a new `ShiftExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
ShiftExpression, |
||||||
|
AdditiveExpression, |
||||||
|
[ |
||||||
|
Punctuator::LeftSh, |
||||||
|
Punctuator::RightSh, |
||||||
|
Punctuator::URightSh |
||||||
|
], |
||||||
|
[allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses an additive expression.
|
||||||
|
///
|
||||||
|
/// This can be either an addition or a subtraction.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-additive-operators
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct AdditiveExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl AdditiveExpression { |
||||||
|
/// Creates a new `AdditiveExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
AdditiveExpression, |
||||||
|
MultiplicativeExpression, |
||||||
|
[Punctuator::Add, Punctuator::Sub], |
||||||
|
[allow_yield, allow_await] |
||||||
|
); |
||||||
|
|
||||||
|
/// Parses a multiplicative expression.
|
||||||
|
///
|
||||||
|
/// This can be either a multiplication, division or a modulo (remainder) expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Division
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-multiplicative-operators
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct MultiplicativeExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl MultiplicativeExpression { |
||||||
|
/// Creates a new `MultiplicativeExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
expression!( |
||||||
|
MultiplicativeExpression, |
||||||
|
ExponentiationExpression, |
||||||
|
[Punctuator::Mul, Punctuator::Div, Punctuator::Mod], |
||||||
|
[allow_yield, allow_await] |
||||||
|
); |
||||||
@ -0,0 +1,82 @@ |
|||||||
|
//! Array initializer parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-array-initializer
|
||||||
|
|
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{constant::Const, node::Node, punc::Punctuator}, |
||||||
|
parser::{ |
||||||
|
expression::AssignmentExpression, AllowAwait, AllowYield, Cursor, ParseError, ParseResult, |
||||||
|
TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses an array literal.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ArrayLiteral
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct ArrayLiteral { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ArrayLiteral { |
||||||
|
/// Creates a new `ArrayLiteral` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ArrayLiteral { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let mut elements = Vec::new(); |
||||||
|
|
||||||
|
loop { |
||||||
|
// TODO: Support all features.
|
||||||
|
while cursor.next_if(Punctuator::Comma).is_some() { |
||||||
|
elements.push(Node::Const(Const::Undefined)); |
||||||
|
} |
||||||
|
|
||||||
|
if cursor.next_if(Punctuator::CloseBracket).is_some() { |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
let _ = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; // Check that there are more tokens to read.
|
||||||
|
|
||||||
|
if cursor.next_if(Punctuator::Spread).is_some() { |
||||||
|
let node = AssignmentExpression::new(true, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
elements.push(Node::spread(node)); |
||||||
|
} else { |
||||||
|
elements.push( |
||||||
|
AssignmentExpression::new(true, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
); |
||||||
|
} |
||||||
|
cursor.next_if(Punctuator::Comma); |
||||||
|
} |
||||||
|
|
||||||
|
Ok(Node::ArrayDecl(elements)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,102 @@ |
|||||||
|
// ! Tests for array initializer parsing.
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{constant::Const, node::Node}, |
||||||
|
parser::tests::check_parser, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Checks an empty array.
|
||||||
|
#[test] |
||||||
|
fn check_empty() { |
||||||
|
check_parser("[]", &[Node::ArrayDecl(Vec::new())]); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks an array with empty slot.
|
||||||
|
#[test] |
||||||
|
fn check_empty_slot() { |
||||||
|
check_parser( |
||||||
|
"[,]", |
||||||
|
&[Node::ArrayDecl(vec![Node::Const(Const::Undefined)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks a numeric array.
|
||||||
|
#[test] |
||||||
|
fn check_numeric_array() { |
||||||
|
check_parser( |
||||||
|
"[1, 2, 3]", |
||||||
|
&[Node::ArrayDecl(vec![ |
||||||
|
Node::const_node(1.0), |
||||||
|
Node::const_node(2.0), |
||||||
|
Node::const_node(3.0), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
// Checks a numeric array with trailing comma
|
||||||
|
#[test] |
||||||
|
fn check_numeric_array_trailing() { |
||||||
|
check_parser( |
||||||
|
"[1, 2, 3,]", |
||||||
|
&[Node::ArrayDecl(vec![ |
||||||
|
Node::const_node(1.0), |
||||||
|
Node::const_node(2.0), |
||||||
|
Node::const_node(3.0), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks a numeric array with an elision.
|
||||||
|
#[test] |
||||||
|
fn check_numeric_array_elision() { |
||||||
|
check_parser( |
||||||
|
"[1, 2, , 3]", |
||||||
|
&[Node::ArrayDecl(vec![ |
||||||
|
Node::const_node(1.0), |
||||||
|
Node::const_node(2.0), |
||||||
|
Node::Const(Const::Undefined), |
||||||
|
Node::const_node(3.0), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks a numeric array with repeated elisions.
|
||||||
|
#[test] |
||||||
|
fn check_numeric_array_repeated_elision() { |
||||||
|
check_parser( |
||||||
|
"[1, 2, ,, 3]", |
||||||
|
&[Node::ArrayDecl(vec![ |
||||||
|
Node::const_node(1.0), |
||||||
|
Node::const_node(2.0), |
||||||
|
Node::Const(Const::Undefined), |
||||||
|
Node::Const(Const::Undefined), |
||||||
|
Node::const_node(3.0), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks a combined array.
|
||||||
|
#[test] |
||||||
|
fn check_combined() { |
||||||
|
check_parser( |
||||||
|
"[1, \"a\", 2]", |
||||||
|
&[Node::ArrayDecl(vec![ |
||||||
|
Node::const_node(1.0), |
||||||
|
Node::const_node("a"), |
||||||
|
Node::const_node(2.0), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks a combined array with an empty string
|
||||||
|
#[test] |
||||||
|
fn check_combined_empty_str() { |
||||||
|
check_parser( |
||||||
|
"[1, \"\", 2]", |
||||||
|
&[Node::ArrayDecl(vec![ |
||||||
|
Node::const_node(1.0), |
||||||
|
Node::const_node(""), |
||||||
|
Node::const_node(2.0), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,60 @@ |
|||||||
|
//! Function expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#prod-FunctionExpression
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
function::{FormalParameters, FunctionBody}, |
||||||
|
Cursor, ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Function expression parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FunctionExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct FunctionExpression; |
||||||
|
|
||||||
|
impl TokenParser for FunctionExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let name = if let TokenKind::Identifier(name) = |
||||||
|
&cursor.peek(0).ok_or(ParseError::AbruptEnd)?.kind |
||||||
|
{ |
||||||
|
Some(name) |
||||||
|
} else { |
||||||
|
None |
||||||
|
}; |
||||||
|
if name.is_some() { |
||||||
|
// We move the cursor forward.
|
||||||
|
let _ = cursor.next().expect("nex token disappeared"); |
||||||
|
} |
||||||
|
|
||||||
|
cursor.expect(Punctuator::OpenParen, "function expression")?; |
||||||
|
|
||||||
|
let params = FormalParameters::new(false, false).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseParen, "function expression")?; |
||||||
|
cursor.expect(Punctuator::OpenBlock, "function expression")?; |
||||||
|
|
||||||
|
let body = FunctionBody::new(false, false) |
||||||
|
.parse(cursor) |
||||||
|
.map(Node::StatementList)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseBlock, "function expression")?; |
||||||
|
|
||||||
|
Ok(Node::function_decl::<_, &String, _, _>(name, params, body)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,94 @@ |
|||||||
|
//! Primary expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators#Primary_expressions
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#prod-PrimaryExpression
|
||||||
|
|
||||||
|
mod array_initializer; |
||||||
|
mod function_expression; |
||||||
|
mod object_initializer; |
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use self::{ |
||||||
|
array_initializer::ArrayLiteral, function_expression::FunctionExpression, |
||||||
|
object_initializer::ObjectLiteral, |
||||||
|
}; |
||||||
|
use super::Expression; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{constant::Const, keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
pub(in crate::syntax::parser) use object_initializer::Initializer; |
||||||
|
|
||||||
|
/// Parses a primary expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Primary_expressions
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-PrimaryExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct PrimaryExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl PrimaryExpression { |
||||||
|
/// Creates a new `PrimaryExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for PrimaryExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
match &tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::This) => Ok(Node::This), |
||||||
|
// TokenKind::Keyword(Keyword::Arguments) => Ok(Node::new(NodeBase::Arguments, tok.pos)),
|
||||||
|
TokenKind::Keyword(Keyword::Function) => FunctionExpression.parse(cursor), |
||||||
|
TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||||
|
let expr = |
||||||
|
Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::CloseParen, "primary expression")?; |
||||||
|
Ok(expr) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBracket) => { |
||||||
|
ArrayLiteral::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBlock) => { |
||||||
|
ObjectLiteral::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::BooleanLiteral(boolean) => Ok(Node::const_node(*boolean)), |
||||||
|
// TODO: ADD TokenKind::UndefinedLiteral
|
||||||
|
TokenKind::Identifier(ref i) if i == "undefined" => Ok(Node::Const(Const::Undefined)), |
||||||
|
TokenKind::NullLiteral => Ok(Node::Const(Const::Null)), |
||||||
|
TokenKind::Identifier(ident) => Ok(Node::local(ident)), |
||||||
|
TokenKind::StringLiteral(s) => Ok(Node::const_node(s)), |
||||||
|
TokenKind::NumericLiteral(num) => Ok(Node::const_node(*num)), |
||||||
|
TokenKind::RegularExpressionLiteral(body, flags) => Ok(Node::new(Node::call( |
||||||
|
Node::local("RegExp"), |
||||||
|
vec![Node::const_node(body), Node::const_node(flags)], |
||||||
|
))), |
||||||
|
_ => Err(ParseError::Unexpected( |
||||||
|
tok.clone(), |
||||||
|
Some("primary expression"), |
||||||
|
)), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,290 @@ |
|||||||
|
//! Object initializer parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-object-initializer
|
||||||
|
|
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{ |
||||||
|
node::{self, MethodDefinitionKind, Node}, |
||||||
|
punc::Punctuator, |
||||||
|
token::{Token, TokenKind}, |
||||||
|
}, |
||||||
|
parser::{ |
||||||
|
expression::AssignmentExpression, |
||||||
|
function::{FormalParameters, FunctionBody}, |
||||||
|
AllowAwait, AllowIn, AllowYield, Cursor, ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses an object literal.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ObjectLiteral
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct ObjectLiteral { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ObjectLiteral { |
||||||
|
/// Creates a new `ObjectLiteral` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ObjectLiteral { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let mut elements = Vec::new(); |
||||||
|
|
||||||
|
loop { |
||||||
|
if cursor.next_if(Punctuator::CloseBlock).is_some() { |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
elements |
||||||
|
.push(PropertyDefinition::new(self.allow_yield, self.allow_await).parse(cursor)?); |
||||||
|
|
||||||
|
if cursor.next_if(Punctuator::CloseBlock).is_some() { |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
if cursor.next_if(Punctuator::Comma).is_none() { |
||||||
|
let next_token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![ |
||||||
|
TokenKind::Punctuator(Punctuator::Comma), |
||||||
|
TokenKind::Punctuator(Punctuator::CloseBlock), |
||||||
|
], |
||||||
|
next_token.clone(), |
||||||
|
"object literal", |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(Node::Object(elements)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Parses a property definition.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-PropertyDefinition
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct PropertyDefinition { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl PropertyDefinition { |
||||||
|
/// Creates a new `PropertyDefinition` parser.
|
||||||
|
fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for PropertyDefinition { |
||||||
|
type Output = node::PropertyDefinition; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
if cursor.next_if(Punctuator::Spread).is_some() { |
||||||
|
let node = AssignmentExpression::new(true, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
return Ok(node::PropertyDefinition::SpreadObject(node)); |
||||||
|
} |
||||||
|
|
||||||
|
let prop_name = cursor |
||||||
|
.next() |
||||||
|
.map(Token::to_string) |
||||||
|
.ok_or(ParseError::AbruptEnd)?; |
||||||
|
if cursor.next_if(Punctuator::Colon).is_some() { |
||||||
|
let val = AssignmentExpression::new(true, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?; |
||||||
|
return Ok(node::PropertyDefinition::Property(prop_name, val)); |
||||||
|
} |
||||||
|
|
||||||
|
if cursor |
||||||
|
.next_if(TokenKind::Punctuator(Punctuator::OpenParen)) |
||||||
|
.is_some() |
||||||
|
|| ["get", "set"].contains(&prop_name.as_str()) |
||||||
|
{ |
||||||
|
return MethodDefinition::new(self.allow_yield, self.allow_await, prop_name) |
||||||
|
.parse(cursor); |
||||||
|
} |
||||||
|
|
||||||
|
let pos = cursor |
||||||
|
.peek(0) |
||||||
|
.map(|tok| tok.pos) |
||||||
|
.ok_or(ParseError::AbruptEnd)?; |
||||||
|
Err(ParseError::General( |
||||||
|
"expected property definition", |
||||||
|
Some(pos), |
||||||
|
)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Parses a method definition.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-MethodDefinition
|
||||||
|
#[derive(Debug, Clone)] |
||||||
|
struct MethodDefinition { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
identifier: String, |
||||||
|
} |
||||||
|
|
||||||
|
impl MethodDefinition { |
||||||
|
/// Creates a new `MethodDefinition` parser.
|
||||||
|
fn new<Y, A, I>(allow_yield: Y, allow_await: A, identifier: I) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
I: Into<String>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
identifier: identifier.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for MethodDefinition { |
||||||
|
type Output = node::PropertyDefinition; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
let (methodkind, prop_name, params) = match self.identifier.as_str() { |
||||||
|
idn @ "get" | idn @ "set" => { |
||||||
|
let prop_name = cursor |
||||||
|
.next() |
||||||
|
.map(Token::to_string) |
||||||
|
.ok_or(ParseError::AbruptEnd)?; |
||||||
|
cursor.expect( |
||||||
|
TokenKind::Punctuator(Punctuator::OpenParen), |
||||||
|
"property method definition", |
||||||
|
)?; |
||||||
|
let first_param = cursor.peek(0).expect("current token disappeared").clone(); |
||||||
|
let params = FormalParameters::new(false, false).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::CloseParen, "method definition")?; |
||||||
|
if idn == "get" { |
||||||
|
if !params.is_empty() { |
||||||
|
return Err(ParseError::Unexpected( |
||||||
|
first_param, |
||||||
|
Some("getter functions must have no arguments"), |
||||||
|
)); |
||||||
|
} |
||||||
|
(MethodDefinitionKind::Get, prop_name, params) |
||||||
|
} else { |
||||||
|
if params.len() != 1 { |
||||||
|
return Err(ParseError::Unexpected( |
||||||
|
first_param, |
||||||
|
Some("setter functions must have one argument"), |
||||||
|
)); |
||||||
|
} |
||||||
|
(MethodDefinitionKind::Set, prop_name, params) |
||||||
|
} |
||||||
|
} |
||||||
|
prop_name => { |
||||||
|
let params = FormalParameters::new(false, false).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::CloseParen, "method definition")?; |
||||||
|
( |
||||||
|
MethodDefinitionKind::Ordinary, |
||||||
|
prop_name.to_string(), |
||||||
|
params, |
||||||
|
) |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
cursor.expect( |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBlock), |
||||||
|
"property method definition", |
||||||
|
)?; |
||||||
|
let body = FunctionBody::new(false, false) |
||||||
|
.parse(cursor) |
||||||
|
.map(Node::StatementList)?; |
||||||
|
cursor.expect( |
||||||
|
TokenKind::Punctuator(Punctuator::CloseBlock), |
||||||
|
"property method definition", |
||||||
|
)?; |
||||||
|
|
||||||
|
Ok(node::PropertyDefinition::MethodDefinition( |
||||||
|
methodkind, |
||||||
|
prop_name, |
||||||
|
Node::FunctionDecl(None, params, Box::new(body)), |
||||||
|
)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Initializer parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-Initializer
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser) struct Initializer { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl Initializer { |
||||||
|
/// Creates a new `Initializer` parser.
|
||||||
|
pub(in crate::syntax::parser) fn new<I, Y, A>( |
||||||
|
allow_in: I, |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for Initializer { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(TokenKind::Punctuator(Punctuator::Assign), "initializer")?; |
||||||
|
AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,131 @@ |
|||||||
|
use crate::syntax::{ |
||||||
|
ast::node::{FormalParameter, MethodDefinitionKind, Node, PropertyDefinition}, |
||||||
|
parser::tests::check_parser, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Checks object literal parsing.
|
||||||
|
#[test] |
||||||
|
fn check_object_literal() { |
||||||
|
let object_properties = vec![ |
||||||
|
PropertyDefinition::property("a", Node::const_node(true)), |
||||||
|
PropertyDefinition::property("b", Node::const_node(false)), |
||||||
|
]; |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"const x = { |
||||||
|
a: true, |
||||||
|
b: false, |
||||||
|
}; |
||||||
|
", |
||||||
|
&[Node::const_decl(vec![( |
||||||
|
String::from("x"), |
||||||
|
Node::Object(object_properties), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Tests short function syntax.
|
||||||
|
#[test] |
||||||
|
fn check_object_short_function() { |
||||||
|
let object_properties = vec![ |
||||||
|
PropertyDefinition::property("a", Node::const_node(true)), |
||||||
|
PropertyDefinition::method_definition( |
||||||
|
MethodDefinitionKind::Ordinary, |
||||||
|
"b", |
||||||
|
Node::function_decl::<_, String, _, _>(None, Vec::new(), Node::StatementList(vec![])), |
||||||
|
), |
||||||
|
]; |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"const x = { |
||||||
|
a: true, |
||||||
|
b() {}, |
||||||
|
}; |
||||||
|
", |
||||||
|
&[Node::ConstDecl(vec![( |
||||||
|
String::from("x"), |
||||||
|
Node::Object(object_properties), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Testing short function syntax with arguments.
|
||||||
|
#[test] |
||||||
|
fn check_object_short_function_arguments() { |
||||||
|
let object_properties = vec![ |
||||||
|
PropertyDefinition::property("a", Node::const_node(true)), |
||||||
|
PropertyDefinition::method_definition( |
||||||
|
MethodDefinitionKind::Ordinary, |
||||||
|
"b", |
||||||
|
Node::function_decl::<_, String, _, _>( |
||||||
|
None, |
||||||
|
vec![FormalParameter::new("test", None, false)], |
||||||
|
Node::StatementList(Vec::new()), |
||||||
|
), |
||||||
|
), |
||||||
|
]; |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"const x = { |
||||||
|
a: true, |
||||||
|
b(test) {} |
||||||
|
}; |
||||||
|
", |
||||||
|
&[Node::ConstDecl(vec![( |
||||||
|
String::from("x"), |
||||||
|
Node::Object(object_properties), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_object_getter() { |
||||||
|
let object_properties = vec![ |
||||||
|
PropertyDefinition::property("a", Node::const_node(true)), |
||||||
|
PropertyDefinition::method_definition( |
||||||
|
MethodDefinitionKind::Get, |
||||||
|
"b", |
||||||
|
Node::FunctionDecl(None, Vec::new(), Box::new(Node::StatementList(Vec::new()))), |
||||||
|
), |
||||||
|
]; |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"const x = { |
||||||
|
a: true, |
||||||
|
get b() {} |
||||||
|
}; |
||||||
|
", |
||||||
|
&[Node::ConstDecl(vec![( |
||||||
|
String::from("x"), |
||||||
|
Node::Object(object_properties), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_object_setter() { |
||||||
|
let object_properties = vec![ |
||||||
|
PropertyDefinition::property("a", Node::const_node(true)), |
||||||
|
PropertyDefinition::method_definition( |
||||||
|
MethodDefinitionKind::Set, |
||||||
|
"b", |
||||||
|
Node::FunctionDecl( |
||||||
|
None, |
||||||
|
vec![FormalParameter::new("test", None, false)], |
||||||
|
Box::new(Node::StatementList(Vec::new())), |
||||||
|
), |
||||||
|
), |
||||||
|
]; |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"const x = { |
||||||
|
a: true, |
||||||
|
set b(test) {} |
||||||
|
}; |
||||||
|
", |
||||||
|
&[Node::ConstDecl(vec![( |
||||||
|
String::from("x"), |
||||||
|
Node::Object(object_properties), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,10 @@ |
|||||||
|
use crate::syntax::{ast::node::Node, parser::tests::check_parser}; |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_string() { |
||||||
|
// Check empty string
|
||||||
|
check_parser("\"\"", &[Node::const_node("")]); |
||||||
|
|
||||||
|
// Check non-empty string
|
||||||
|
check_parser("\"hello\"", &[Node::const_node("hello")]); |
||||||
|
} |
||||||
@ -0,0 +1,293 @@ |
|||||||
|
use crate::syntax::{ |
||||||
|
ast::node::Node, |
||||||
|
ast::op::{AssignOp, BinOp, BitOp, NumOp}, |
||||||
|
parser::tests::check_parser, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Checks numeric operations
|
||||||
|
#[test] |
||||||
|
fn check_numeric_operations() { |
||||||
|
check_parser( |
||||||
|
"a + b", |
||||||
|
&[Node::bin_op(NumOp::Add, Node::local("a"), Node::local("b"))], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a+1", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Add, |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(1.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a - b", |
||||||
|
&[Node::bin_op(NumOp::Sub, Node::local("a"), Node::local("b"))], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a-1", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Sub, |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(1.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a / b", |
||||||
|
&[Node::bin_op(NumOp::Div, Node::local("a"), Node::local("b"))], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a/2", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Div, |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(2.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a * b", |
||||||
|
&[Node::bin_op(NumOp::Mul, Node::local("a"), Node::local("b"))], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a*2", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Mul, |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(2.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a ** b", |
||||||
|
&[Node::bin_op(NumOp::Exp, Node::local("a"), Node::local("b"))], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a**2", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Exp, |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(2.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a % b", |
||||||
|
&[Node::bin_op(NumOp::Mod, Node::local("a"), Node::local("b"))], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a%2", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Mod, |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(2.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
// Checks complex numeric operations.
|
||||||
|
#[test] |
||||||
|
fn check_complex_numeric_operations() { |
||||||
|
check_parser( |
||||||
|
"a + d*(b-3)+1", |
||||||
|
&[Node::bin_op( |
||||||
|
NumOp::Add, |
||||||
|
Node::bin_op( |
||||||
|
NumOp::Add, |
||||||
|
Node::local("a"), |
||||||
|
Node::bin_op( |
||||||
|
NumOp::Mul, |
||||||
|
Node::local("d"), |
||||||
|
Node::bin_op(NumOp::Sub, Node::local("b"), Node::const_node(3.0)), |
||||||
|
), |
||||||
|
), |
||||||
|
Node::const_node(1.0), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks bitwise operations.
|
||||||
|
#[test] |
||||||
|
fn check_bitwise_operations() { |
||||||
|
check_parser( |
||||||
|
"a & b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::And), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a&b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::And), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"a | b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Or), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a|b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Or), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"a ^ b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Xor), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a^b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Xor), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"a << b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Shl), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a<<b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Shl), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
|
||||||
|
check_parser( |
||||||
|
"a >> b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Shr), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a>>b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Bit(BitOp::Shr), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks assignment operations.
|
||||||
|
#[test] |
||||||
|
fn check_assign_operations() { |
||||||
|
check_parser( |
||||||
|
"a += b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Add), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a -= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Sub), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a *= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Mul), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a **= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Exp), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a /= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Div), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a %= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Mod), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a &= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::And), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a |= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Or), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a ^= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Xor), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a <<= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Shl), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a >>= b", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Shr), |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
)], |
||||||
|
); |
||||||
|
check_parser( |
||||||
|
"a %= 10 / 2", |
||||||
|
&[Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Mod), |
||||||
|
Node::local("a"), |
||||||
|
Node::bin_op(NumOp::Div, Node::const_node(10.0), Node::const_node(2.0)), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,79 @@ |
|||||||
|
//! Unary operator parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Unary
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-unary-operators
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, op::UnaryOp, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::update::UpdateExpression, AllowAwait, AllowYield, Cursor, ParseError, |
||||||
|
ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a unary expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Unary
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-UnaryExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct UnaryExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl UnaryExpression { |
||||||
|
/// Creates a new `UnaryExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for UnaryExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::Delete) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::Delete, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Void) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::Void, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::TypeOf) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::TypeOf, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Add) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::Plus, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Sub) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::Minus, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Neg) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::Tilde, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Not) => { |
||||||
|
Ok(Node::unary_op(UnaryOp::Not, self.parse(cursor)?)) |
||||||
|
} |
||||||
|
_ => { |
||||||
|
cursor.back(); |
||||||
|
UpdateExpression::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,82 @@ |
|||||||
|
//! Update expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-update-expressions
|
||||||
|
|
||||||
|
use super::left_hand_side::LeftHandSideExpression; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{node::Node, op::UnaryOp, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses an update expression.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-UpdateExpression
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct UpdateExpression { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl UpdateExpression { |
||||||
|
/// Creates a new `UpdateExpression` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for UpdateExpression { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::Inc) => { |
||||||
|
cursor.next().expect("token disappeared"); |
||||||
|
return Ok(Node::unary_op( |
||||||
|
UnaryOp::IncrementPre, |
||||||
|
LeftHandSideExpression::new(self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
)); |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Dec) => { |
||||||
|
cursor.next().expect("token disappeared"); |
||||||
|
return Ok(Node::unary_op( |
||||||
|
UnaryOp::DecrementPre, |
||||||
|
LeftHandSideExpression::new(self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
)); |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
let lhs = LeftHandSideExpression::new(self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
if let Some(tok) = cursor.peek(0) { |
||||||
|
match tok.kind { |
||||||
|
TokenKind::Punctuator(Punctuator::Inc) => { |
||||||
|
cursor.next().expect("token disappeared"); |
||||||
|
return Ok(Node::unary_op(UnaryOp::IncrementPost, lhs)); |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Dec) => { |
||||||
|
cursor.next().expect("token disappeared"); |
||||||
|
return Ok(Node::unary_op(UnaryOp::DecrementPost, lhs)); |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(lhs) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,238 @@ |
|||||||
|
//! Function definition parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-function-definitions
|
||||||
|
|
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{ |
||||||
|
node::{self, Node}, |
||||||
|
punc::Punctuator, |
||||||
|
token::TokenKind, |
||||||
|
}, |
||||||
|
parser::{statement::StatementList, AllowAwait, AllowYield, Cursor, ParseError, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Formal parameters parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Glossary/Parameter
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FormalParameters
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser) struct FormalParameters { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl FormalParameters { |
||||||
|
/// Creates a new `FormalParameters` parser.
|
||||||
|
pub(in crate::syntax::parser) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for FormalParameters { |
||||||
|
type Output = Vec<node::FormalParameter>; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
let mut params = Vec::new(); |
||||||
|
|
||||||
|
if cursor.peek(0).ok_or(ParseError::AbruptEnd)?.kind |
||||||
|
== TokenKind::Punctuator(Punctuator::CloseParen) |
||||||
|
{ |
||||||
|
return Ok(params); |
||||||
|
} |
||||||
|
|
||||||
|
loop { |
||||||
|
let mut rest_param = false; |
||||||
|
|
||||||
|
params.push(if cursor.next_if(Punctuator::Spread).is_some() { |
||||||
|
rest_param = true; |
||||||
|
FunctionRestParameter::new(self.allow_yield, self.allow_await).parse(cursor)? |
||||||
|
} else { |
||||||
|
FormalParameter::new(self.allow_yield, self.allow_await).parse(cursor)? |
||||||
|
}); |
||||||
|
|
||||||
|
if cursor.peek(0).ok_or(ParseError::AbruptEnd)?.kind |
||||||
|
== TokenKind::Punctuator(Punctuator::CloseParen) |
||||||
|
{ |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
if rest_param { |
||||||
|
return Err(ParseError::Unexpected( |
||||||
|
cursor |
||||||
|
.peek_prev() |
||||||
|
.expect("current token disappeared") |
||||||
|
.clone(), |
||||||
|
Some("rest parameter must be the last formal parameter"), |
||||||
|
)); |
||||||
|
} |
||||||
|
|
||||||
|
cursor.expect(Punctuator::Comma, "parameter list")?; |
||||||
|
} |
||||||
|
|
||||||
|
Ok(params) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Rest parameter parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FunctionRestParameter
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct FunctionRestParameter { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl FunctionRestParameter { |
||||||
|
/// Creates a new `FunctionRestParameter` parser.
|
||||||
|
fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for FunctionRestParameter { |
||||||
|
type Output = node::FormalParameter; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
let token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
Ok(Self::Output::new( |
||||||
|
if let TokenKind::Identifier(name) = &token.kind { |
||||||
|
name |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
token.clone(), |
||||||
|
"rest parameter", |
||||||
|
)); |
||||||
|
}, |
||||||
|
None, |
||||||
|
true, |
||||||
|
)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Formal parameter parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Glossary/Parameter
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FormalParameter
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct FormalParameter { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl FormalParameter { |
||||||
|
/// Creates a new `FormalParameter` parser.
|
||||||
|
fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for FormalParameter { |
||||||
|
type Output = node::FormalParameter; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
let token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let name = if let TokenKind::Identifier(name) = &token.kind { |
||||||
|
name |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
token.clone(), |
||||||
|
"formal parameter", |
||||||
|
)); |
||||||
|
}; |
||||||
|
|
||||||
|
// TODO: Implement initializer.
|
||||||
|
Ok(Self::Output::new(name, None, false)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// A `FunctionBody` is equivalent to a `FunctionStatementList`.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FunctionBody
|
||||||
|
pub(in crate::syntax::parser) type FunctionBody = FunctionStatementList; |
||||||
|
|
||||||
|
/// A function statement list
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FunctionStatementList
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser) struct FunctionStatementList { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl FunctionStatementList { |
||||||
|
/// Creates a new `FunctionStatementList` parser.
|
||||||
|
pub(in crate::syntax::parser) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for FunctionStatementList { |
||||||
|
type Output = Vec<Node>; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
if let Some(tk) = cursor.peek(0) { |
||||||
|
if tk.kind == Punctuator::CloseBlock.into() { |
||||||
|
return Ok(Vec::new()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
StatementList::new(self.allow_yield, self.allow_await, true, true).parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,169 @@ |
|||||||
|
use crate::syntax::{ |
||||||
|
ast::node::{FormalParameter, Node}, |
||||||
|
ast::op::NumOp, |
||||||
|
parser::tests::check_parser, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Checks basic function declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_basic() { |
||||||
|
check_parser( |
||||||
|
"function foo(a) { return a; }", |
||||||
|
&[Node::function_decl( |
||||||
|
"foo", |
||||||
|
vec![FormalParameter::new("a", None, false)], |
||||||
|
Node::StatementList(vec![Node::return_node(Node::local("a"))]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks basic function declaration parsing with automatic semicolon insertion.
|
||||||
|
#[test] |
||||||
|
fn check_basic_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"function foo(a) { return a }", |
||||||
|
&[Node::function_decl( |
||||||
|
"foo", |
||||||
|
vec![FormalParameter::new("a", None, false)], |
||||||
|
Node::StatementList(vec![Node::return_node(Node::local("a"))]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks functions with empty returns.
|
||||||
|
#[test] |
||||||
|
fn check_empty_return() { |
||||||
|
check_parser( |
||||||
|
"function foo(a) { return; }", |
||||||
|
&[Node::function_decl( |
||||||
|
"foo", |
||||||
|
vec![FormalParameter::new("a", None, false)], |
||||||
|
Node::StatementList(vec![Node::Return(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks functions with empty returns without semicolon
|
||||||
|
#[test] |
||||||
|
fn check_empty_return_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"function foo(a) { return }", |
||||||
|
&[Node::function_decl( |
||||||
|
"foo", |
||||||
|
vec![FormalParameter::new("a", None, false)], |
||||||
|
Node::StatementList(vec![Node::Return(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks rest operator parsing.
|
||||||
|
#[test] |
||||||
|
fn check_rest_operator() { |
||||||
|
check_parser( |
||||||
|
"function foo(a, ...b) {}", |
||||||
|
&[Node::function_decl( |
||||||
|
"foo", |
||||||
|
vec![ |
||||||
|
FormalParameter::new("a", None, false), |
||||||
|
FormalParameter::new("b", None, true), |
||||||
|
], |
||||||
|
Node::StatementList(Vec::new()), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks an arrow function with only a rest parameter.
|
||||||
|
#[test] |
||||||
|
fn check_arrow_only_rest() { |
||||||
|
check_parser( |
||||||
|
"(...a) => {}", |
||||||
|
&[Node::arrow_function_decl( |
||||||
|
vec![FormalParameter::new("a", None, true)], |
||||||
|
Node::StatementList(Vec::new()), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks an arrow function with a rest parameter.
|
||||||
|
#[test] |
||||||
|
fn check_arrow_rest() { |
||||||
|
check_parser( |
||||||
|
"(a, b, ...c) => {}", |
||||||
|
&[Node::arrow_function_decl( |
||||||
|
vec![ |
||||||
|
FormalParameter::new("a", None, false), |
||||||
|
FormalParameter::new("b", None, false), |
||||||
|
FormalParameter::new("c", None, true), |
||||||
|
], |
||||||
|
Node::StatementList(Vec::new()), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks an arrow function with expression return.
|
||||||
|
#[test] |
||||||
|
fn check_arrow() { |
||||||
|
check_parser( |
||||||
|
"(a, b) => { return a + b; }", |
||||||
|
&[Node::arrow_function_decl( |
||||||
|
vec![ |
||||||
|
FormalParameter::new("a", None, false), |
||||||
|
FormalParameter::new("b", None, false), |
||||||
|
], |
||||||
|
Node::StatementList(vec![Node::return_node(Node::bin_op( |
||||||
|
NumOp::Add, |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
))]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks an arrow function with expression return and automatic semicolon insertion
|
||||||
|
#[test] |
||||||
|
fn check_arrow_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"(a, b) => { return a + b }", |
||||||
|
&[Node::arrow_function_decl( |
||||||
|
vec![ |
||||||
|
FormalParameter::new("a", None, false), |
||||||
|
FormalParameter::new("b", None, false), |
||||||
|
], |
||||||
|
Node::StatementList(vec![Node::return_node(Node::bin_op( |
||||||
|
NumOp::Add, |
||||||
|
Node::local("a"), |
||||||
|
Node::local("b"), |
||||||
|
))]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks arrow function with empty return
|
||||||
|
#[test] |
||||||
|
fn check_arrow_epty_return() { |
||||||
|
check_parser( |
||||||
|
"(a, b) => { return; }", |
||||||
|
&[Node::arrow_function_decl( |
||||||
|
vec![ |
||||||
|
FormalParameter::new("a", None, false), |
||||||
|
FormalParameter::new("b", None, false), |
||||||
|
], |
||||||
|
Node::StatementList(vec![Node::Return(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks an arrow function with empty return, with automatic semicolon insertion.
|
||||||
|
#[test] |
||||||
|
fn check_arrow_empty_return_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"(a, b) => { return }", |
||||||
|
&[Node::arrow_function_decl( |
||||||
|
vec![ |
||||||
|
FormalParameter::new("a", None, false), |
||||||
|
FormalParameter::new("b", None, false), |
||||||
|
], |
||||||
|
Node::StatementList(vec![Node::Return(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,203 @@ |
|||||||
|
//! Block statement parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-block
|
||||||
|
|
||||||
|
use super::{declaration::Declaration, Statement}; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// A `BlockStatement` is equivalent to a `Block`.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-BlockStatement
|
||||||
|
pub(super) type BlockStatement = Block; |
||||||
|
|
||||||
|
/// Variable declaration list parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-Block
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct Block { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl Block { |
||||||
|
/// Creates a new `Block` parser.
|
||||||
|
pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for Block { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Punctuator::OpenBlock, "block")?; |
||||||
|
if let Some(tk) = cursor.peek(0) { |
||||||
|
if tk.kind == TokenKind::Punctuator(Punctuator::CloseBlock) { |
||||||
|
cursor.next(); |
||||||
|
return Ok(Node::Block(Vec::new())); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
let statement_list = |
||||||
|
StatementList::new(self.allow_yield, self.allow_await, self.allow_return, true) |
||||||
|
.parse(cursor) |
||||||
|
.map(Node::Block)?; |
||||||
|
cursor.expect(Punctuator::CloseBlock, "block")?; |
||||||
|
|
||||||
|
Ok(statement_list) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Reads a list of statements.
|
||||||
|
///
|
||||||
|
/// If `break_when_closingbrase` is `true`, it will stop as soon as it finds a `}` character.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-StatementList
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser) struct StatementList { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
break_when_closingbrase: bool, |
||||||
|
} |
||||||
|
|
||||||
|
impl StatementList { |
||||||
|
/// Creates a new `StatementList` parser.
|
||||||
|
pub(in crate::syntax::parser) fn new<Y, A, R>( |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
allow_return: R, |
||||||
|
break_when_closingbrase: bool, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
break_when_closingbrase, |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for StatementList { |
||||||
|
type Output = Vec<Node>; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
let mut items = Vec::new(); |
||||||
|
|
||||||
|
loop { |
||||||
|
match cursor.peek(0) { |
||||||
|
Some(token) if token.kind == TokenKind::Punctuator(Punctuator::CloseBlock) => { |
||||||
|
if self.break_when_closingbrase { |
||||||
|
break; |
||||||
|
} else { |
||||||
|
return Err(ParseError::Unexpected(token.clone(), None)); |
||||||
|
} |
||||||
|
} |
||||||
|
None => { |
||||||
|
if self.break_when_closingbrase { |
||||||
|
return Err(ParseError::AbruptEnd); |
||||||
|
} else { |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
let item = |
||||||
|
StatementListItem::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor)?; |
||||||
|
items.push(item); |
||||||
|
|
||||||
|
// move the cursor forward for any consecutive semicolon.
|
||||||
|
while cursor.next_if(Punctuator::Semicolon).is_some() {} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(items) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Statement list item parsing
|
||||||
|
///
|
||||||
|
/// A statement list item can either be an statement or a declaration.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-StatementListItem
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct StatementListItem { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl StatementListItem { |
||||||
|
/// Creates a new `StatementListItem` parser.
|
||||||
|
fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for StatementListItem { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::Function) |
||||||
|
| TokenKind::Keyword(Keyword::Const) |
||||||
|
| TokenKind::Keyword(Keyword::Let) => { |
||||||
|
Declaration::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
_ => { |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,78 @@ |
|||||||
|
//! Break expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/break
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-break-statement
|
||||||
|
|
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Break statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/break
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-BreakStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct BreakStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl BreakStatement { |
||||||
|
/// Creates a new `BreakStatement` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for BreakStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Break, "break statement")?; |
||||||
|
|
||||||
|
if let (true, tok) = cursor.peek_semicolon(false) { |
||||||
|
match tok { |
||||||
|
Some(tok) if tok.kind == TokenKind::Punctuator(Punctuator::Semicolon) => { |
||||||
|
let _ = cursor.next(); |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
return Ok(Node::Break(None)); |
||||||
|
} |
||||||
|
|
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let node = if let TokenKind::Identifier(name) = &tok.kind { |
||||||
|
Node::break_node(name) |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
tok.clone(), |
||||||
|
"break statement", |
||||||
|
)); |
||||||
|
}; |
||||||
|
|
||||||
|
cursor.expect_semicolon(false, "break statement")?; |
||||||
|
|
||||||
|
Ok(node) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,92 @@ |
|||||||
|
use crate::syntax::{ast::node::Node, parser::tests::check_parser}; |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_inline() { |
||||||
|
check_parser( |
||||||
|
"while (true) break;", |
||||||
|
&[Node::while_loop(Node::const_node(true), Node::Break(None))], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line() { |
||||||
|
check_parser( |
||||||
|
"while (true) |
||||||
|
break;", |
||||||
|
&[Node::while_loop(Node::const_node(true), Node::Break(None))], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_inline_block_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"while (true) {break}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Break(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
break test |
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::break_node("test")]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_inline_block() { |
||||||
|
check_parser( |
||||||
|
"while (true) {break;}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Break(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_block() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
break test; |
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::break_node("test")]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_block_empty() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
break; |
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Break(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_block_empty_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
break
|
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Break(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,78 @@ |
|||||||
|
//! Continue expression parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/continue
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-continue-statement
|
||||||
|
|
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// For statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/continue
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ContinueStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct ContinueStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ContinueStatement { |
||||||
|
/// Creates a new `ContinueStatement` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ContinueStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Continue, "continue statement")?; |
||||||
|
|
||||||
|
if let (true, tok) = cursor.peek_semicolon(false) { |
||||||
|
match tok { |
||||||
|
Some(tok) if tok.kind == TokenKind::Punctuator(Punctuator::Semicolon) => { |
||||||
|
let _ = cursor.next(); |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
return Ok(Node::Continue(None)); |
||||||
|
} |
||||||
|
|
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let node = if let TokenKind::Identifier(name) = &tok.kind { |
||||||
|
Node::continue_node(name) |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
tok.clone(), |
||||||
|
"continue statement", |
||||||
|
)); |
||||||
|
}; |
||||||
|
|
||||||
|
cursor.expect_semicolon(false, "continue statement")?; |
||||||
|
|
||||||
|
Ok(node) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,98 @@ |
|||||||
|
use crate::syntax::{ast::node::Node, parser::tests::check_parser}; |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_inline() { |
||||||
|
check_parser( |
||||||
|
"while (true) continue;", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Continue(None), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line() { |
||||||
|
check_parser( |
||||||
|
"while (true) |
||||||
|
continue;", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Continue(None), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_inline_block_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"while (true) {continue}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Continue(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
continue test |
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::continue_node("test")]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_inline_block() { |
||||||
|
check_parser( |
||||||
|
"while (true) {continue;}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Continue(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_block() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
continue test; |
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::continue_node("test")]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_block_empty() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
continue; |
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Continue(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_new_line_block_empty_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
"while (true) { |
||||||
|
continue
|
||||||
|
}", |
||||||
|
&[Node::while_loop( |
||||||
|
Node::const_node(true), |
||||||
|
Node::Block(vec![Node::Continue(None)]), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,118 @@ |
|||||||
|
//! Hoistable declaration parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#prod-HoistableDeclaration
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
function::FormalParameters, function::FunctionBody, AllowAwait, AllowDefault, AllowYield, |
||||||
|
Cursor, ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Hoistable declaration parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FunctionDeclaration
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct HoistableDeclaration { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_default: AllowDefault, |
||||||
|
} |
||||||
|
|
||||||
|
impl HoistableDeclaration { |
||||||
|
/// Creates a new `HoistableDeclaration` parser.
|
||||||
|
pub(super) fn new<Y, A, D>(allow_yield: Y, allow_await: A, allow_default: D) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
D: Into<AllowDefault>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_default: allow_default.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for HoistableDeclaration { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// TODO: check for generators and async functions + generators
|
||||||
|
FunctionDeclaration::new(self.allow_yield, self.allow_await, self.allow_default) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Function declaration parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-FunctionDeclaration
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct FunctionDeclaration { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_default: AllowDefault, |
||||||
|
} |
||||||
|
|
||||||
|
impl FunctionDeclaration { |
||||||
|
/// Creates a new `FunctionDeclaration` parser.
|
||||||
|
fn new<Y, A, D>(allow_yield: Y, allow_await: A, allow_default: D) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
D: Into<AllowDefault>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_default: allow_default.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for FunctionDeclaration { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Function, "function declaration")?; |
||||||
|
|
||||||
|
let token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let name = if let TokenKind::Identifier(name) = &token.kind { |
||||||
|
name.clone() |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("function name")], |
||||||
|
token.clone(), |
||||||
|
"function declaration", |
||||||
|
)); |
||||||
|
}; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::OpenParen, "function declaration")?; |
||||||
|
|
||||||
|
let params = FormalParameters::new(false, false).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseParen, "function declaration")?; |
||||||
|
cursor.expect(Punctuator::OpenBlock, "function declaration")?; |
||||||
|
|
||||||
|
let body = FunctionBody::new(self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor) |
||||||
|
.map(Node::StatementList)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseBlock, "function declaration")?; |
||||||
|
|
||||||
|
Ok(Node::function_decl(name, params, body)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,172 @@ |
|||||||
|
//! Lexical declaration parsing.
|
||||||
|
//!
|
||||||
|
//! This parses `let` and `const` declarations.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-let-and-const-declarations
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::Initializer, AllowAwait, AllowIn, AllowYield, Cursor, ParseError, ParseResult, |
||||||
|
TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a lexical declaration.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-LexicalDeclaration
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct LexicalDeclaration { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl LexicalDeclaration { |
||||||
|
/// Creates a new `LexicalDeclaration` parser.
|
||||||
|
pub(super) fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for LexicalDeclaration { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::Const) => { |
||||||
|
BindingList::new(self.allow_in, self.allow_yield, self.allow_await, true) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Let) => { |
||||||
|
BindingList::new(self.allow_in, self.allow_yield, self.allow_await, false) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
_ => unreachable!("unknown token found"), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Parses a binding list.
|
||||||
|
///
|
||||||
|
/// It will return an error if a `const` declaration is being parsed and there is no
|
||||||
|
/// initializer.
|
||||||
|
///
|
||||||
|
/// More information: <https://tc39.es/ecma262/#prod-BindingList>.
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct BindingList { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
is_const: bool, |
||||||
|
} |
||||||
|
|
||||||
|
impl BindingList { |
||||||
|
/// Creates a new `BindingList` parser.
|
||||||
|
fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A, is_const: bool) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
is_const, |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for BindingList { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// Create vectors to store the variable declarations
|
||||||
|
// Const and Let signatures are slightly different, Const needs definitions, Lets don't
|
||||||
|
let mut let_decls = Vec::new(); |
||||||
|
let mut const_decls = Vec::new(); |
||||||
|
|
||||||
|
loop { |
||||||
|
let token = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let name = if let TokenKind::Identifier(ref name) = token.kind { |
||||||
|
name.clone() |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
token.clone(), |
||||||
|
if self.is_const { |
||||||
|
"const declaration" |
||||||
|
} else { |
||||||
|
"let declaration" |
||||||
|
}, |
||||||
|
)); |
||||||
|
}; |
||||||
|
|
||||||
|
match cursor.peek(0) { |
||||||
|
Some(token) if token.kind == TokenKind::Punctuator(Punctuator::Assign) => { |
||||||
|
let init = Some( |
||||||
|
Initializer::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
); |
||||||
|
if self.is_const { |
||||||
|
const_decls.push((name, init.unwrap())); |
||||||
|
} else { |
||||||
|
let_decls.push((name, init)); |
||||||
|
}; |
||||||
|
} |
||||||
|
_ => { |
||||||
|
if self.is_const { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::Punctuator(Punctuator::Assign)], |
||||||
|
cursor.next().ok_or(ParseError::AbruptEnd)?.clone(), |
||||||
|
"const declaration", |
||||||
|
)); |
||||||
|
} else { |
||||||
|
let_decls.push((name, None)); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
match cursor.peek_semicolon(false) { |
||||||
|
(true, _) => break, |
||||||
|
(false, Some(tk)) if tk.kind == TokenKind::Punctuator(Punctuator::Comma) => { |
||||||
|
let _ = cursor.next(); |
||||||
|
} |
||||||
|
_ => { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![ |
||||||
|
TokenKind::Punctuator(Punctuator::Semicolon), |
||||||
|
TokenKind::LineTerminator, |
||||||
|
], |
||||||
|
cursor.next().ok_or(ParseError::AbruptEnd)?.clone(), |
||||||
|
"lexical declaration", |
||||||
|
)) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if self.is_const { |
||||||
|
Ok(Node::ConstDecl(const_decls)) |
||||||
|
} else { |
||||||
|
Ok(Node::LetDecl(let_decls)) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,62 @@ |
|||||||
|
//! Declaration parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements#Declarations
|
||||||
|
//! [spec]:https://tc39.es/ecma262/#sec-declarations-and-the-variable-statement
|
||||||
|
|
||||||
|
mod hoistable; |
||||||
|
mod lexical; |
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use self::{hoistable::HoistableDeclaration, lexical::LexicalDeclaration}; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Parses a declaration.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-Declaration
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct Declaration { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl Declaration { |
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for Declaration { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::Function) => { |
||||||
|
HoistableDeclaration::new(self.allow_yield, self.allow_await, false).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Const) | TokenKind::Keyword(Keyword::Let) => { |
||||||
|
LexicalDeclaration::new(true, self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
_ => unreachable!("unknown token found"), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,132 @@ |
|||||||
|
use crate::syntax::{ |
||||||
|
ast::node::Node, |
||||||
|
parser::tests::{check_invalid, check_parser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Checks `var` declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_var_declaration() { |
||||||
|
check_parser( |
||||||
|
"var a = 5;", |
||||||
|
&[Node::VarDecl(vec![( |
||||||
|
String::from("a"), |
||||||
|
Some(Node::const_node(5.0)), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks `var` declaration parsing with no spaces.
|
||||||
|
#[test] |
||||||
|
fn check_var_declaration_no_spaces() { |
||||||
|
check_parser( |
||||||
|
"var a=5;", |
||||||
|
&[Node::VarDecl(vec![( |
||||||
|
String::from("a"), |
||||||
|
Some(Node::const_node(5.0)), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks empty `var` declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_empty_var_declaration() { |
||||||
|
check_parser("var a;", &[Node::VarDecl(vec![(String::from("a"), None)])]); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks multiple `var` declarations.
|
||||||
|
#[test] |
||||||
|
fn check_multiple_var_declaration() { |
||||||
|
check_parser( |
||||||
|
"var a = 5, b, c = 6;", |
||||||
|
&[Node::VarDecl(vec![ |
||||||
|
(String::from("a"), Some(Node::const_node(5.0))), |
||||||
|
(String::from("b"), None), |
||||||
|
(String::from("c"), Some(Node::const_node(6.0))), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks `let` declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_let_declaration() { |
||||||
|
check_parser( |
||||||
|
"let a = 5;", |
||||||
|
&[Node::LetDecl(vec![( |
||||||
|
String::from("a"), |
||||||
|
Some(Node::const_node(5.0)), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks `let` declaration parsing with no spaces.
|
||||||
|
#[test] |
||||||
|
fn check_let_declaration_no_spaces() { |
||||||
|
check_parser( |
||||||
|
"let a=5;", |
||||||
|
&[Node::LetDecl(vec![( |
||||||
|
String::from("a"), |
||||||
|
Some(Node::const_node(5.0)), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks empty `let` declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_empty_let_declaration() { |
||||||
|
check_parser("let a;", &[Node::LetDecl(vec![(String::from("a"), None)])]); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks multiple `let` declarations.
|
||||||
|
#[test] |
||||||
|
fn check_multiple_let_declaration() { |
||||||
|
check_parser( |
||||||
|
"let a = 5, b, c = 6;", |
||||||
|
&[Node::LetDecl(vec![ |
||||||
|
(String::from("a"), Some(Node::const_node(5.0))), |
||||||
|
(String::from("b"), None), |
||||||
|
(String::from("c"), Some(Node::const_node(6.0))), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks `const` declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_const_declaration() { |
||||||
|
check_parser( |
||||||
|
"const a = 5;", |
||||||
|
&[Node::ConstDecl(vec![( |
||||||
|
String::from("a"), |
||||||
|
Node::const_node(5.0), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks `const` declaration parsing with no spaces.
|
||||||
|
#[test] |
||||||
|
fn check_const_declaration_no_spaces() { |
||||||
|
check_parser( |
||||||
|
"const a=5;", |
||||||
|
&[Node::ConstDecl(vec![( |
||||||
|
String::from("a"), |
||||||
|
Node::const_node(5.0), |
||||||
|
)])], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks empty `const` declaration parsing.
|
||||||
|
#[test] |
||||||
|
fn check_empty_const_declaration() { |
||||||
|
check_invalid("const a;"); |
||||||
|
} |
||||||
|
|
||||||
|
/// Checks multiple `const` declarations.
|
||||||
|
#[test] |
||||||
|
fn check_multiple_const_declaration() { |
||||||
|
check_parser( |
||||||
|
"const a = 5, c = 6;", |
||||||
|
&[Node::ConstDecl(vec![ |
||||||
|
(String::from("a"), Node::const_node(5.0)), |
||||||
|
(String::from("c"), Node::const_node(6.0)), |
||||||
|
])], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,73 @@ |
|||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use super::Statement; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::Expression, AllowAwait, AllowReturn, AllowYield, Cursor, ParseResult, |
||||||
|
TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// If statement parsing.
|
||||||
|
///
|
||||||
|
/// An _If_ statement will have a condition, a block statemet, and an optional _else_ statement.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-IfStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct IfStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl IfStatement { |
||||||
|
/// Creates a new `IfStatement` parser.
|
||||||
|
pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for IfStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::If, "if statement")?; |
||||||
|
cursor.expect(Punctuator::OpenParen, "if statement")?; |
||||||
|
|
||||||
|
let cond = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseParen, "if statement")?; |
||||||
|
|
||||||
|
let then_stm = |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?; |
||||||
|
|
||||||
|
let else_stm = match cursor.next() { |
||||||
|
Some(else_tok) if else_tok.kind == TokenKind::Keyword(Keyword::Else) => Some( |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor)?, |
||||||
|
), |
||||||
|
_ => { |
||||||
|
cursor.back(); |
||||||
|
None |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
Ok(Node::if_node::<_, _, Node, _>(cond, then_stm, else_stm)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,82 @@ |
|||||||
|
//! Do-while statement parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/do...while
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-do-while-statement
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::Expression, statement::Statement, AllowAwait, AllowReturn, AllowYield, Cursor, |
||||||
|
ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Do...while statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/do...while
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-do-while-statement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::statement) struct DoWhileStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl DoWhileStatement { |
||||||
|
/// Creates a new `DoWhileStatement` parser.
|
||||||
|
pub(in crate::syntax::parser::statement) fn new<Y, A, R>( |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
allow_return: R, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for DoWhileStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Do, "do while statement")?; |
||||||
|
|
||||||
|
let body = |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?; |
||||||
|
|
||||||
|
let next_token = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
if next_token.kind != TokenKind::Keyword(Keyword::While) { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::Keyword(Keyword::While)], |
||||||
|
next_token.clone(), |
||||||
|
"do while statement", |
||||||
|
)); |
||||||
|
} |
||||||
|
|
||||||
|
cursor.expect(Keyword::While, "do while statement")?; |
||||||
|
cursor.expect(Punctuator::OpenParen, "do while statement")?; |
||||||
|
|
||||||
|
let cond = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseParen, "do while statement")?; |
||||||
|
cursor.expect_semicolon(true, "do while statement")?; |
||||||
|
|
||||||
|
Ok(Node::do_while_loop(body, cond)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,102 @@ |
|||||||
|
//! For statement parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-for-statement
|
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::Expression, |
||||||
|
statement::declaration::Declaration, |
||||||
|
statement::{variable::VariableDeclarationList, Statement}, |
||||||
|
AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// For statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-for-statement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::statement) struct ForStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl ForStatement { |
||||||
|
/// Creates a new `ForStatement` parser.
|
||||||
|
pub(in crate::syntax::parser::statement) fn new<Y, A, R>( |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
allow_return: R, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ForStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::For, "for statement")?; |
||||||
|
cursor.expect(Punctuator::OpenParen, "for statement")?; |
||||||
|
|
||||||
|
let init = match cursor.peek(0).ok_or(ParseError::AbruptEnd)?.kind { |
||||||
|
TokenKind::Keyword(Keyword::Var) => Some( |
||||||
|
VariableDeclarationList::new(false, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
), |
||||||
|
TokenKind::Keyword(Keyword::Let) | TokenKind::Keyword(Keyword::Const) => { |
||||||
|
Some(Declaration::new(self.allow_yield, self.allow_await).parse(cursor)?) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::Semicolon) => None, |
||||||
|
_ => Some(Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?), |
||||||
|
}; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::Semicolon, "for statement")?; |
||||||
|
|
||||||
|
let cond = if cursor.next_if(Punctuator::Semicolon).is_some() { |
||||||
|
Node::const_node(true) |
||||||
|
} else { |
||||||
|
let step = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
cursor.expect(Punctuator::Semicolon, "for statement")?; |
||||||
|
step |
||||||
|
}; |
||||||
|
|
||||||
|
let step = if cursor.next_if(Punctuator::CloseParen).is_some() { |
||||||
|
None |
||||||
|
} else { |
||||||
|
let step = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
cursor.expect( |
||||||
|
TokenKind::Punctuator(Punctuator::CloseParen), |
||||||
|
"for statement", |
||||||
|
)?; |
||||||
|
Some(step) |
||||||
|
}; |
||||||
|
|
||||||
|
let body = |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?; |
||||||
|
|
||||||
|
let for_node = Node::for_loop::<_, _, _, Node, Node, Node, _>(init, cond, step, body); |
||||||
|
|
||||||
|
Ok(Node::Block(vec![for_node])) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,10 @@ |
|||||||
|
mod do_while_statement; |
||||||
|
mod for_statement; |
||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
mod while_statement; |
||||||
|
|
||||||
|
pub(super) use self::{ |
||||||
|
do_while_statement::DoWhileStatement, for_statement::ForStatement, |
||||||
|
while_statement::WhileStatement, |
||||||
|
}; |
||||||
@ -0,0 +1,50 @@ |
|||||||
|
use crate::syntax::{ |
||||||
|
ast::node::Node, |
||||||
|
ast::op::{AssignOp, BinOp, CompOp, UnaryOp}, |
||||||
|
parser::tests::check_parser, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Checks do-while statement parsing.
|
||||||
|
#[test] |
||||||
|
fn check_do_while() { |
||||||
|
check_parser( |
||||||
|
r#"do { |
||||||
|
a += 1; |
||||||
|
} while (true)"#, |
||||||
|
&[Node::do_while_loop( |
||||||
|
Node::Block(vec![Node::bin_op( |
||||||
|
BinOp::Assign(AssignOp::Add), |
||||||
|
Node::local("a"), |
||||||
|
Node::const_node(1.0), |
||||||
|
)]), |
||||||
|
Node::const_node(true), |
||||||
|
)], |
||||||
|
); |
||||||
|
} |
||||||
|
|
||||||
|
// Checks automatic semicolon insertion after do-while.
|
||||||
|
#[test] |
||||||
|
fn check_do_while_semicolon_insertion() { |
||||||
|
check_parser( |
||||||
|
r#"var i = 0; |
||||||
|
do {console.log("hello");} while(i++ < 10) console.log("end");"#, |
||||||
|
&[ |
||||||
|
Node::VarDecl(vec![(String::from("i"), Some(Node::const_node(0.0)))]), |
||||||
|
Node::do_while_loop( |
||||||
|
Node::Block(vec![Node::call( |
||||||
|
Node::get_const_field(Node::local("console"), "log"), |
||||||
|
vec![Node::const_node("hello")], |
||||||
|
)]), |
||||||
|
Node::bin_op( |
||||||
|
BinOp::Comp(CompOp::LessThan), |
||||||
|
Node::unary_op(UnaryOp::IncrementPost, Node::local("i")), |
||||||
|
Node::const_node(10.0), |
||||||
|
), |
||||||
|
), |
||||||
|
Node::call( |
||||||
|
Node::get_const_field(Node::local("console"), "log"), |
||||||
|
vec![Node::const_node("end")], |
||||||
|
), |
||||||
|
], |
||||||
|
); |
||||||
|
} |
||||||
@ -0,0 +1,60 @@ |
|||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator}, |
||||||
|
parser::{ |
||||||
|
expression::Expression, statement::Statement, AllowAwait, AllowReturn, AllowYield, Cursor, |
||||||
|
ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// While statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-while-statement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::statement) struct WhileStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl WhileStatement { |
||||||
|
/// Creates a new `WhileStatement` parser.
|
||||||
|
pub(in crate::syntax::parser::statement) fn new<Y, A, R>( |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
allow_return: R, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for WhileStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::While, "while statement")?; |
||||||
|
cursor.expect(Punctuator::OpenParen, "while statement")?; |
||||||
|
|
||||||
|
let cond = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseParen, "while statement")?; |
||||||
|
|
||||||
|
let body = |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?; |
||||||
|
|
||||||
|
Ok(Node::while_loop(cond, body)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,318 @@ |
|||||||
|
//! Statement and declaration parsing.
|
||||||
|
//!
|
||||||
|
//! More information:
|
||||||
|
//! - [MDN documentation][mdn]
|
||||||
|
//! - [ECMAScript specification][spec]
|
||||||
|
//!
|
||||||
|
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements
|
||||||
|
//! [spec]: https://tc39.es/ecma262/#sec-ecmascript-language-statements-and-declarations
|
||||||
|
|
||||||
|
mod block; |
||||||
|
mod break_stm; |
||||||
|
mod continue_stm; |
||||||
|
mod declaration; |
||||||
|
mod if_stm; |
||||||
|
mod iteration; |
||||||
|
mod return_stm; |
||||||
|
mod switch; |
||||||
|
mod throw; |
||||||
|
mod try_stm; |
||||||
|
mod variable; |
||||||
|
|
||||||
|
use self::{ |
||||||
|
block::BlockStatement, |
||||||
|
break_stm::BreakStatement, |
||||||
|
continue_stm::ContinueStatement, |
||||||
|
declaration::Declaration, |
||||||
|
if_stm::IfStatement, |
||||||
|
iteration::{DoWhileStatement, ForStatement, WhileStatement}, |
||||||
|
return_stm::ReturnStatement, |
||||||
|
switch::SwitchStatement, |
||||||
|
throw::ThrowStatement, |
||||||
|
try_stm::TryStatement, |
||||||
|
variable::VariableStatement, |
||||||
|
}; |
||||||
|
use super::{ |
||||||
|
expression::Expression, AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, ParseResult, |
||||||
|
TokenParser, |
||||||
|
}; |
||||||
|
use crate::syntax::ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}; |
||||||
|
|
||||||
|
/// Statement parsing.
|
||||||
|
///
|
||||||
|
/// This can be one of the following:
|
||||||
|
///
|
||||||
|
/// - `BlockStatement`
|
||||||
|
/// - `VariableStatement`
|
||||||
|
/// - `EmptyStatement`
|
||||||
|
/// - `ExpressionStatement`
|
||||||
|
/// - `IfStatement`
|
||||||
|
/// - `BreakableStatement`
|
||||||
|
/// - `ContinueStatement`
|
||||||
|
/// - `BreakStatement`
|
||||||
|
/// - `ReturnStatement`
|
||||||
|
/// - `WithStatement`
|
||||||
|
/// - `LabelledStatement`
|
||||||
|
/// - `ThrowStatement`
|
||||||
|
/// - `TryStatement`
|
||||||
|
/// - `DebuggerStatement`
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-Statement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct Statement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl Statement { |
||||||
|
/// Creates a new `Statement` parser.
|
||||||
|
pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for Statement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// TODO: add BreakableStatement and divide Whiles, fors and so on to another place.
|
||||||
|
let tok = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::If) => { |
||||||
|
IfStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Var) => { |
||||||
|
VariableStatement::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::While) => { |
||||||
|
WhileStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Do) => { |
||||||
|
DoWhileStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::For) => { |
||||||
|
ForStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Return) => { |
||||||
|
if self.allow_return.0 { |
||||||
|
ReturnStatement::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} else { |
||||||
|
Err(ParseError::Unexpected(tok.clone(), Some("statement"))) |
||||||
|
} |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Break) => { |
||||||
|
BreakStatement::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Continue) => { |
||||||
|
ContinueStatement::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Try) => { |
||||||
|
TryStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Throw) => { |
||||||
|
ThrowStatement::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Keyword(Keyword::Switch) => { |
||||||
|
SwitchStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
TokenKind::Punctuator(Punctuator::OpenBlock) => { |
||||||
|
BlockStatement::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor) |
||||||
|
} |
||||||
|
// TODO: https://tc39.es/ecma262/#prod-LabelledStatement
|
||||||
|
// TokenKind::Punctuator(Punctuator::Semicolon) => {
|
||||||
|
// return Ok(Node::new(NodeBase::Nope, tok.pos))
|
||||||
|
// }
|
||||||
|
_ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Reads a list of statements.
|
||||||
|
///
|
||||||
|
/// If `break_when_closingbrase` is `true`, it will stop as soon as it finds a `}` character.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-StatementList
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct StatementList { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
break_when_closingbrase: bool, |
||||||
|
} |
||||||
|
|
||||||
|
impl StatementList { |
||||||
|
/// Creates a new `StatementList` parser.
|
||||||
|
pub(super) fn new<Y, A, R>( |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
allow_return: R, |
||||||
|
break_when_closingbrase: bool, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
break_when_closingbrase, |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for StatementList { |
||||||
|
type Output = Vec<Node>; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Vec<Node>, ParseError> { |
||||||
|
let mut items = Vec::new(); |
||||||
|
|
||||||
|
loop { |
||||||
|
match cursor.peek(0) { |
||||||
|
Some(token) if token.kind == TokenKind::Punctuator(Punctuator::CloseBlock) => { |
||||||
|
if self.break_when_closingbrase { |
||||||
|
break; |
||||||
|
} else { |
||||||
|
return Err(ParseError::Unexpected(token.clone(), None)); |
||||||
|
} |
||||||
|
} |
||||||
|
None => { |
||||||
|
if self.break_when_closingbrase { |
||||||
|
return Err(ParseError::AbruptEnd); |
||||||
|
} else { |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
let item = |
||||||
|
StatementListItem::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor)?; |
||||||
|
items.push(item); |
||||||
|
|
||||||
|
// move the cursor forward for any consecutive semicolon.
|
||||||
|
while cursor.next_if(Punctuator::Semicolon).is_some() {} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(items) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Statement list item parsing
|
||||||
|
///
|
||||||
|
/// A statement list item can either be an statement or a declaration.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-StatementListItem
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct StatementListItem { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl StatementListItem { |
||||||
|
/// Creates a new `StatementListItem` parser.
|
||||||
|
fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for StatementListItem { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let tok = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
match tok.kind { |
||||||
|
TokenKind::Keyword(Keyword::Function) |
||||||
|
| TokenKind::Keyword(Keyword::Const) |
||||||
|
| TokenKind::Keyword(Keyword::Let) => { |
||||||
|
Declaration::new(self.allow_yield, self.allow_await).parse(cursor) |
||||||
|
} |
||||||
|
_ => { |
||||||
|
Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Expression statement parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ExpressionStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct ExpressionStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ExpressionStatement { |
||||||
|
/// Creates a new `ExpressionStatement` parser.
|
||||||
|
fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ExpressionStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// TODO: lookahead
|
||||||
|
let expr = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect_semicolon(false, "expression statement")?; |
||||||
|
|
||||||
|
Ok(expr) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,63 @@ |
|||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{expression::Expression, AllowAwait, AllowYield, Cursor, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Return statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ReturnStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct ReturnStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ReturnStatement { |
||||||
|
/// Creates a new `ReturnStatement` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ReturnStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Return, "return statement")?; |
||||||
|
|
||||||
|
if let (true, tok) = cursor.peek_semicolon(false) { |
||||||
|
match tok { |
||||||
|
Some(tok) |
||||||
|
if tok.kind == TokenKind::Punctuator(Punctuator::Semicolon) |
||||||
|
|| tok.kind == TokenKind::LineTerminator => |
||||||
|
{ |
||||||
|
let _ = cursor.next(); |
||||||
|
} |
||||||
|
_ => {} |
||||||
|
} |
||||||
|
|
||||||
|
return Ok(Node::Return(None)); |
||||||
|
} |
||||||
|
|
||||||
|
let expr = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect_semicolon(false, "return statement")?; |
||||||
|
|
||||||
|
Ok(Node::return_node(expr)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,101 @@ |
|||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator}, |
||||||
|
parser::{ |
||||||
|
expression::Expression, AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, |
||||||
|
ParseResult, TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Switch statement parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-SwitchStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct SwitchStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl SwitchStatement { |
||||||
|
/// Creates a new `SwitchStatement` parser.
|
||||||
|
pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for SwitchStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Switch, "switch statement")?; |
||||||
|
cursor.expect(Punctuator::OpenParen, "switch statement")?; |
||||||
|
|
||||||
|
let condition = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect(Punctuator::CloseParen, "switch statement")?; |
||||||
|
|
||||||
|
let (cases, default) = |
||||||
|
CaseBlock::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?; |
||||||
|
|
||||||
|
Ok(Node::switch::<_, _, _, Node>(condition, cases, default)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Switch case block parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-CaseBlock
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct CaseBlock { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl CaseBlock { |
||||||
|
/// Creates a new `CaseBlock` parser.
|
||||||
|
fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for CaseBlock { |
||||||
|
type Output = (Vec<(Node, Vec<Node>)>, Option<Node>); |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
cursor.expect(Punctuator::OpenBlock, "switch case block")?; |
||||||
|
|
||||||
|
// CaseClauses[?Yield, ?Await, ?Return]opt
|
||||||
|
// CaseClauses[?Yield, ?Await, ?Return]optDefaultClause[?Yield, ?Await, ?Return]CaseClauses[?Yield, ?Await, ?Return]opt
|
||||||
|
|
||||||
|
unimplemented!("switch case block parsing") |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,54 @@ |
|||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{expression::Expression, AllowAwait, AllowYield, Cursor, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// For statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-ThrowStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct ThrowStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl ThrowStatement { |
||||||
|
/// Creates a new `ThrowStatement` parser.
|
||||||
|
pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for ThrowStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Throw, "throw statement")?; |
||||||
|
|
||||||
|
cursor.peek_expect_no_lineterminator(0, "throw statement")?; |
||||||
|
|
||||||
|
let expr = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
if let Some(tok) = cursor.peek(0) { |
||||||
|
if tok.kind == TokenKind::Punctuator(Punctuator::Semicolon) { |
||||||
|
let _ = cursor.next(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(Node::throw(expr)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,6 @@ |
|||||||
|
use crate::syntax::{ast::node::Node, parser::tests::check_parser}; |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn check_throw_parsing() { |
||||||
|
check_parser("throw 'error';", &[Node::throw(Node::const_node("error"))]); |
||||||
|
} |
||||||
@ -0,0 +1,109 @@ |
|||||||
|
#[cfg(test)] |
||||||
|
mod tests; |
||||||
|
|
||||||
|
use super::block::Block; |
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, ParseResult, TokenParser}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Try...catch statement parsing
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#sec-try-statement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(super) struct TryStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
allow_return: AllowReturn, |
||||||
|
} |
||||||
|
|
||||||
|
impl TryStatement { |
||||||
|
/// Creates a new `TryStatement` parser.
|
||||||
|
pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
R: Into<AllowReturn>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
allow_return: allow_return.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for TryStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
// TRY
|
||||||
|
cursor.expect(Keyword::Try, "try statement")?; |
||||||
|
|
||||||
|
let try_clause = |
||||||
|
Block::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?; |
||||||
|
|
||||||
|
let next_token = cursor.peek(0).ok_or(ParseError::AbruptEnd)?; |
||||||
|
|
||||||
|
if next_token.kind != TokenKind::Keyword(Keyword::Catch) |
||||||
|
&& next_token.kind != TokenKind::Keyword(Keyword::Finally) |
||||||
|
{ |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![ |
||||||
|
TokenKind::Keyword(Keyword::Catch), |
||||||
|
TokenKind::Keyword(Keyword::Finally), |
||||||
|
], |
||||||
|
next_token.clone(), |
||||||
|
"try statement", |
||||||
|
)); |
||||||
|
} |
||||||
|
|
||||||
|
// CATCH
|
||||||
|
let (catch, param) = if next_token.kind == TokenKind::Keyword(Keyword::Catch) { |
||||||
|
// Catch binding
|
||||||
|
cursor.expect(Punctuator::OpenParen, "catch in try statement")?; |
||||||
|
// TODO: should accept BindingPattern
|
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let catch_param = if let TokenKind::Identifier(s) = &tok.kind { |
||||||
|
Node::local(s) |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
tok.clone(), |
||||||
|
"catch in try statement", |
||||||
|
)); |
||||||
|
}; |
||||||
|
cursor.expect(Punctuator::CloseParen, "catch in try statement")?; |
||||||
|
|
||||||
|
// Catch block
|
||||||
|
( |
||||||
|
Some( |
||||||
|
Block::new(self.allow_yield, self.allow_await, self.allow_return) |
||||||
|
.parse(cursor)?, |
||||||
|
), |
||||||
|
Some(catch_param), |
||||||
|
) |
||||||
|
} else { |
||||||
|
(None, None) |
||||||
|
}; |
||||||
|
|
||||||
|
// FINALLY
|
||||||
|
let finally_block = if cursor.next_if(Keyword::Finally).is_some() { |
||||||
|
Some(Block::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?) |
||||||
|
} else { |
||||||
|
None |
||||||
|
}; |
||||||
|
|
||||||
|
Ok(Node::try_node::<_, _, _, _, Node, Node, Node>( |
||||||
|
try_clause, |
||||||
|
catch, |
||||||
|
param, |
||||||
|
finally_block, |
||||||
|
)) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,179 @@ |
|||||||
|
// use super::lexical_declaration_continuation;
|
||||||
|
use crate::syntax::{ |
||||||
|
ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind}, |
||||||
|
parser::{ |
||||||
|
expression::Initializer, AllowAwait, AllowIn, AllowYield, Cursor, ParseError, ParseResult, |
||||||
|
TokenParser, |
||||||
|
}, |
||||||
|
}; |
||||||
|
|
||||||
|
/// Variable statement parsing.
|
||||||
|
///
|
||||||
|
/// A varible statement contains the `var` keyword.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-VariableStatement
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::statement) struct VariableStatement { |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl VariableStatement { |
||||||
|
/// Creates a new `VariableStatement` parser.
|
||||||
|
pub(in crate::syntax::parser::statement) fn new<Y, A>(allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for VariableStatement { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
cursor.expect(Keyword::Var, "variable statement")?; |
||||||
|
|
||||||
|
let decl_list = |
||||||
|
VariableDeclarationList::new(true, self.allow_yield, self.allow_await).parse(cursor)?; |
||||||
|
|
||||||
|
cursor.expect_semicolon(false, "variable statement")?; |
||||||
|
|
||||||
|
Ok(decl_list) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Variable declaration list parsing.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [MDN documentation][mdn]
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-VariableDeclarationList
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
pub(in crate::syntax::parser::statement) struct VariableDeclarationList { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl VariableDeclarationList { |
||||||
|
/// Creates a new `VariableDeclarationList` parser.
|
||||||
|
pub(in crate::syntax::parser::statement) fn new<I, Y, A>( |
||||||
|
allow_in: I, |
||||||
|
allow_yield: Y, |
||||||
|
allow_await: A, |
||||||
|
) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for VariableDeclarationList { |
||||||
|
type Output = Node; |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> ParseResult { |
||||||
|
let mut list = Vec::new(); |
||||||
|
|
||||||
|
loop { |
||||||
|
list.push( |
||||||
|
VariableDeclaration::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
); |
||||||
|
|
||||||
|
match cursor.peek_semicolon(false) { |
||||||
|
(true, _) => break, |
||||||
|
(false, Some(tk)) if tk.kind == TokenKind::Punctuator(Punctuator::Comma) => { |
||||||
|
let _ = cursor.next(); |
||||||
|
} |
||||||
|
_ => { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![ |
||||||
|
TokenKind::Punctuator(Punctuator::Semicolon), |
||||||
|
TokenKind::LineTerminator, |
||||||
|
], |
||||||
|
cursor.next().ok_or(ParseError::AbruptEnd)?.clone(), |
||||||
|
"lexical declaration", |
||||||
|
)) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Ok(Node::VarDecl(list)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Reads an individual variable declaration.
|
||||||
|
///
|
||||||
|
/// More information:
|
||||||
|
/// - [ECMAScript specification][spec]
|
||||||
|
///
|
||||||
|
/// [spec]: https://tc39.es/ecma262/#prod-VariableDeclaration
|
||||||
|
#[derive(Debug, Clone, Copy)] |
||||||
|
struct VariableDeclaration { |
||||||
|
allow_in: AllowIn, |
||||||
|
allow_yield: AllowYield, |
||||||
|
allow_await: AllowAwait, |
||||||
|
} |
||||||
|
|
||||||
|
impl VariableDeclaration { |
||||||
|
/// Creates a new `VariableDeclaration` parser.
|
||||||
|
fn new<I, Y, A>(allow_in: I, allow_yield: Y, allow_await: A) -> Self |
||||||
|
where |
||||||
|
I: Into<AllowIn>, |
||||||
|
Y: Into<AllowYield>, |
||||||
|
A: Into<AllowAwait>, |
||||||
|
{ |
||||||
|
Self { |
||||||
|
allow_in: allow_in.into(), |
||||||
|
allow_yield: allow_yield.into(), |
||||||
|
allow_await: allow_await.into(), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
impl TokenParser for VariableDeclaration { |
||||||
|
type Output = (String, Option<Node>); |
||||||
|
|
||||||
|
fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> { |
||||||
|
let tok = cursor.next().ok_or(ParseError::AbruptEnd)?; |
||||||
|
let name = if let TokenKind::Identifier(name) = &tok.kind { |
||||||
|
name.clone() |
||||||
|
} else { |
||||||
|
return Err(ParseError::Expected( |
||||||
|
vec![TokenKind::identifier("identifier")], |
||||||
|
tok.clone(), |
||||||
|
"variable declaration", |
||||||
|
)); |
||||||
|
}; |
||||||
|
|
||||||
|
match cursor.peek(0) { |
||||||
|
Some(tk) if tk.kind == TokenKind::Punctuator(Punctuator::Assign) => Ok(( |
||||||
|
name, |
||||||
|
Some( |
||||||
|
Initializer::new(self.allow_in, self.allow_yield, self.allow_await) |
||||||
|
.parse(cursor)?, |
||||||
|
), |
||||||
|
)), |
||||||
|
_ => Ok((name, None)), |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue