mirror of https://github.com/boa-dev/boa.git
Browse Source
This Pull Request implements optional chains.
Example:
```Javascript
const adventurer = {
name: 'Alice',
cat: {
name: 'Dinah'
}
};
console.log(adventurer.cat?.name); // Dinah
console.log(adventurer.dog?.name); // undefined
```
Since I needed to implement `Opcode::RotateLeft`, and #2378 had an implementation for `Opcode::RotateRight`, I took the opportunity to integrate both ops into this PR (big thanks to @HalidOdat for the original implementation!).
This PR almost has 100% conformance for the `optional-chaining` test suite. However, there's this one [test](85373b4ce1/test/language/expressions/optional-chaining/member-expression.js) that can't be solved until we properly set function names for function expressions in object and class definitions.
pull/2391/head
José Julián Espina
2 years ago
17 changed files with 898 additions and 113 deletions
@ -0,0 +1,202 @@
|
||||
use boa_interner::{Interner, Sym, ToInternedString}; |
||||
|
||||
use crate::syntax::ast::{join_nodes, ContainsSymbol}; |
||||
|
||||
use super::{access::PropertyAccessField, Expression}; |
||||
|
||||
/// List of valid operations in an [`Optional`] chain.
|
||||
#[cfg_attr(feature = "deser", derive(serde::Serialize, serde::Deserialize))] |
||||
#[derive(Clone, Debug, PartialEq)] |
||||
pub enum OptionalOperationKind { |
||||
/// A property access (`a?.prop`).
|
||||
SimplePropertyAccess { |
||||
/// The field accessed.
|
||||
field: PropertyAccessField, |
||||
}, |
||||
/// A private property access (`a?.#prop`).
|
||||
PrivatePropertyAccess { |
||||
/// The private property accessed.
|
||||
field: Sym, |
||||
}, |
||||
/// A function call (`a?.(arg)`).
|
||||
Call { |
||||
/// The args passed to the function call.
|
||||
args: Box<[Expression]>, |
||||
}, |
||||
} |
||||
|
||||
impl OptionalOperationKind { |
||||
#[inline] |
||||
pub(crate) fn contains_arguments(&self) -> bool { |
||||
match self { |
||||
OptionalOperationKind::SimplePropertyAccess { field } => field.contains_arguments(), |
||||
OptionalOperationKind::PrivatePropertyAccess { .. } => false, |
||||
OptionalOperationKind::Call { args } => args.iter().any(Expression::contains_arguments), |
||||
} |
||||
} |
||||
#[inline] |
||||
pub(crate) fn contains(&self, symbol: ContainsSymbol) -> bool { |
||||
match self { |
||||
OptionalOperationKind::SimplePropertyAccess { field } => field.contains(symbol), |
||||
OptionalOperationKind::PrivatePropertyAccess { .. } => false, |
||||
OptionalOperationKind::Call { args } => args.iter().any(|e| e.contains(symbol)), |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Operation within an [`Optional`] chain.
|
||||
///
|
||||
/// An operation within an `Optional` chain can be either shorted or non-shorted. A shorted operation
|
||||
/// (`?.item`) will force the expression to return `undefined` if the target is `undefined` or `null`.
|
||||
/// In contrast, a non-shorted operation (`.prop`) will try to access the property, even if the target
|
||||
/// is `undefined` or `null`.
|
||||
#[cfg_attr(feature = "deser", derive(serde::Serialize, serde::Deserialize))] |
||||
#[derive(Clone, Debug, PartialEq)] |
||||
pub struct OptionalOperation { |
||||
kind: OptionalOperationKind, |
||||
shorted: bool, |
||||
} |
||||
|
||||
impl OptionalOperation { |
||||
/// Creates a new `OptionalOperation`.
|
||||
#[inline] |
||||
pub fn new(kind: OptionalOperationKind, shorted: bool) -> Self { |
||||
Self { kind, shorted } |
||||
} |
||||
/// Gets the kind of operation.
|
||||
#[inline] |
||||
pub fn kind(&self) -> &OptionalOperationKind { |
||||
&self.kind |
||||
} |
||||
|
||||
/// Returns `true` if the operation short-circuits the [`Optional`] chain when the target is
|
||||
/// `undefined` or `null`.
|
||||
#[inline] |
||||
pub fn shorted(&self) -> bool { |
||||
self.shorted |
||||
} |
||||
|
||||
#[inline] |
||||
pub(crate) fn contains_arguments(&self) -> bool { |
||||
self.kind.contains_arguments() |
||||
} |
||||
|
||||
#[inline] |
||||
pub(crate) fn contains(&self, symbol: ContainsSymbol) -> bool { |
||||
self.kind.contains(symbol) |
||||
} |
||||
} |
||||
|
||||
impl ToInternedString for OptionalOperation { |
||||
fn to_interned_string(&self, interner: &Interner) -> String { |
||||
let mut buf = if self.shorted { |
||||
String::from("?.") |
||||
} else { |
||||
if let OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const(name), |
||||
} = &self.kind |
||||
{ |
||||
return format!(".{}", interner.resolve_expect(*name)); |
||||
} |
||||
|
||||
if let OptionalOperationKind::PrivatePropertyAccess { field } = &self.kind { |
||||
return format!(".#{}", interner.resolve_expect(*field)); |
||||
} |
||||
|
||||
String::new() |
||||
}; |
||||
buf.push_str(&match &self.kind { |
||||
OptionalOperationKind::SimplePropertyAccess { field } => match field { |
||||
PropertyAccessField::Const(name) => interner.resolve_expect(*name).to_string(), |
||||
PropertyAccessField::Expr(expr) => { |
||||
format!("[{}]", expr.to_interned_string(interner)) |
||||
} |
||||
}, |
||||
OptionalOperationKind::PrivatePropertyAccess { field } => { |
||||
format!("#{}", interner.resolve_expect(*field)) |
||||
} |
||||
OptionalOperationKind::Call { args } => format!("({})", join_nodes(interner, args)), |
||||
}); |
||||
buf |
||||
} |
||||
} |
||||
|
||||
/// An optional chain expression, as defined by the [spec].
|
||||
///
|
||||
/// [Optional chaining][mdn] allows for short-circuiting property accesses and function calls, which
|
||||
/// will return `undefined` instead of returning an error if the access target or the call is
|
||||
/// either `undefined` or `null`.
|
||||
///
|
||||
/// An example of optional chaining:
|
||||
///
|
||||
/// ```Javascript
|
||||
/// const adventurer = {
|
||||
/// name: 'Alice',
|
||||
/// cat: {
|
||||
/// name: 'Dinah'
|
||||
/// }
|
||||
/// };
|
||||
///
|
||||
/// console.log(adventurer.cat?.name); // Dinah
|
||||
/// console.log(adventurer.dog?.name); // undefined
|
||||
/// ```
|
||||
///
|
||||
/// [spec]: https://tc39.es/ecma262/multipage/ecmascript-language-expressions.html#prod-OptionalExpression
|
||||
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining
|
||||
#[cfg_attr(feature = "deser", derive(serde::Serialize, serde::Deserialize))] |
||||
#[derive(Clone, Debug, PartialEq)] |
||||
pub struct Optional { |
||||
target: Box<Expression>, |
||||
chain: Box<[OptionalOperation]>, |
||||
} |
||||
|
||||
impl Optional { |
||||
/// Creates a new `Optional` expression.
|
||||
#[inline] |
||||
pub fn new(target: Expression, chain: Box<[OptionalOperation]>) -> Self { |
||||
Self { |
||||
target: Box::new(target), |
||||
chain, |
||||
} |
||||
} |
||||
|
||||
/// Gets the target of this `Optional` expression.
|
||||
#[inline] |
||||
pub fn target(&self) -> &Expression { |
||||
self.target.as_ref() |
||||
} |
||||
|
||||
/// Gets the chain of accesses and calls that will be applied to the target at runtime.
|
||||
#[inline] |
||||
pub fn chain(&self) -> &[OptionalOperation] { |
||||
self.chain.as_ref() |
||||
} |
||||
|
||||
#[inline] |
||||
pub(crate) fn contains_arguments(&self) -> bool { |
||||
self.target.contains_arguments() |
||||
|| self.chain.iter().any(OptionalOperation::contains_arguments) |
||||
} |
||||
#[inline] |
||||
pub(crate) fn contains(&self, symbol: ContainsSymbol) -> bool { |
||||
self.target.contains(symbol) || self.chain.iter().any(|item| item.contains(symbol)) |
||||
} |
||||
} |
||||
|
||||
impl From<Optional> for Expression { |
||||
fn from(opt: Optional) -> Self { |
||||
Expression::Optional(opt) |
||||
} |
||||
} |
||||
|
||||
impl ToInternedString for Optional { |
||||
fn to_interned_string(&self, interner: &Interner) -> String { |
||||
let mut buf = self.target.to_interned_string(interner); |
||||
|
||||
for item in &*self.chain { |
||||
buf.push_str(&item.to_interned_string(interner)); |
||||
} |
||||
|
||||
buf |
||||
} |
||||
} |
||||
@ -0,0 +1,168 @@
|
||||
#[cfg(test)] |
||||
mod tests; |
||||
|
||||
use std::io::Read; |
||||
|
||||
use boa_interner::{Interner, Sym}; |
||||
use boa_profiler::Profiler; |
||||
|
||||
use crate::syntax::{ |
||||
ast::{ |
||||
self, |
||||
expression::{ |
||||
access::PropertyAccessField, Optional, OptionalOperation, OptionalOperationKind, |
||||
}, |
||||
Punctuator, |
||||
}, |
||||
lexer::{Token, TokenKind}, |
||||
parser::{ |
||||
cursor::Cursor, expression::Expression, AllowAwait, AllowYield, ParseError, ParseResult, |
||||
TokenParser, |
||||
}, |
||||
}; |
||||
|
||||
use super::arguments::Arguments; |
||||
|
||||
/// Parses an optional expression.
|
||||
///
|
||||
/// More information:
|
||||
/// - [MDN documentation][mdn]
|
||||
/// - [ECMAScript specification][spec]
|
||||
///
|
||||
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining
|
||||
/// [spec]: https://tc39.es/ecma262/multipage/ecmascript-language-expressions.html#prod-OptionalExpression
|
||||
#[derive(Debug, Clone)] |
||||
pub(in crate::syntax::parser) struct OptionalExpression { |
||||
allow_yield: AllowYield, |
||||
allow_await: AllowAwait, |
||||
target: ast::Expression, |
||||
} |
||||
|
||||
impl OptionalExpression { |
||||
/// Creates a new `OptionalExpression` parser.
|
||||
pub(in crate::syntax::parser) fn new<Y, A>( |
||||
allow_yield: Y, |
||||
allow_await: A, |
||||
target: ast::Expression, |
||||
) -> Self |
||||
where |
||||
Y: Into<AllowYield>, |
||||
A: Into<AllowAwait>, |
||||
{ |
||||
Self { |
||||
allow_yield: allow_yield.into(), |
||||
allow_await: allow_await.into(), |
||||
target, |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<R> TokenParser<R> for OptionalExpression |
||||
where |
||||
R: Read, |
||||
{ |
||||
type Output = Optional; |
||||
|
||||
fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> { |
||||
fn parse_const_access<R: Read>( |
||||
cursor: &mut Cursor<R>, |
||||
token: &Token, |
||||
interner: &mut Interner, |
||||
) -> ParseResult<OptionalOperationKind> { |
||||
let item = match token.kind() { |
||||
TokenKind::Identifier(name) => OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const(*name), |
||||
}, |
||||
TokenKind::Keyword((kw, _)) => OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const(kw.to_sym(interner)), |
||||
}, |
||||
TokenKind::BooleanLiteral(true) => OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const(Sym::TRUE), |
||||
}, |
||||
TokenKind::BooleanLiteral(false) => OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const(Sym::FALSE), |
||||
}, |
||||
TokenKind::NullLiteral => OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const(Sym::NULL), |
||||
}, |
||||
TokenKind::PrivateIdentifier(name) => { |
||||
cursor.push_used_private_identifier(*name, token.span().start())?; |
||||
OptionalOperationKind::PrivatePropertyAccess { field: *name } |
||||
} |
||||
_ => { |
||||
return Err(ParseError::expected( |
||||
["identifier".to_owned()], |
||||
token.to_string(interner), |
||||
token.span(), |
||||
"optional chain", |
||||
)) |
||||
} |
||||
}; |
||||
Ok(item) |
||||
} |
||||
let _timer = Profiler::global().start_event("OptionalExpression", "Parsing"); |
||||
|
||||
let mut items = Vec::new(); |
||||
|
||||
while let Some(token) = cursor.peek(0, interner)? { |
||||
let shorted = match token.kind() { |
||||
TokenKind::Punctuator(Punctuator::Optional) => { |
||||
cursor.next(interner).expect("token disappeared"); |
||||
true |
||||
} |
||||
TokenKind::Punctuator(Punctuator::OpenParen | Punctuator::OpenBracket) => false, |
||||
TokenKind::Punctuator(Punctuator::Dot) => { |
||||
cursor.next(interner).expect("token disappeared"); |
||||
let field = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?; |
||||
|
||||
let item = parse_const_access(cursor, &field, interner)?; |
||||
|
||||
items.push(OptionalOperation::new(item, false)); |
||||
continue; |
||||
} |
||||
TokenKind::TemplateMiddle(_) | TokenKind::TemplateNoSubstitution(_) => { |
||||
return Err(ParseError::general( |
||||
"Invalid tagged template on optional chain", |
||||
token.span().start(), |
||||
)) |
||||
} |
||||
_ => break, |
||||
}; |
||||
|
||||
let token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?; |
||||
|
||||
let item = match token.kind() { |
||||
TokenKind::Punctuator(Punctuator::OpenParen) => { |
||||
let args = Arguments::new(self.allow_yield, self.allow_await) |
||||
.parse(cursor, interner)?; |
||||
OptionalOperationKind::Call { args } |
||||
} |
||||
TokenKind::Punctuator(Punctuator::OpenBracket) => { |
||||
cursor |
||||
.next(interner)? |
||||
.expect("open bracket punctuator token disappeared"); // We move the parser forward.
|
||||
let idx = Expression::new(None, true, self.allow_yield, self.allow_await) |
||||
.parse(cursor, interner)?; |
||||
cursor.expect(Punctuator::CloseBracket, "optional chain", interner)?; |
||||
OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Expr(Box::new(idx)), |
||||
} |
||||
} |
||||
TokenKind::TemplateMiddle(_) | TokenKind::TemplateNoSubstitution(_) => { |
||||
return Err(ParseError::general( |
||||
"Invalid tagged template on optional chain", |
||||
token.span().start(), |
||||
)) |
||||
} |
||||
_ => { |
||||
let token = cursor.next(interner)?.expect("token disappeared"); |
||||
parse_const_access(cursor, &token, interner)? |
||||
} |
||||
}; |
||||
|
||||
items.push(OptionalOperation::new(item, shorted)); |
||||
} |
||||
|
||||
Ok(Optional::new(self.target, items.into())) |
||||
} |
||||
} |
||||
@ -0,0 +1,93 @@
|
||||
use boa_interner::Interner; |
||||
use boa_macros::utf16; |
||||
|
||||
use crate::syntax::{ |
||||
ast::{ |
||||
expression::{ |
||||
access::PropertyAccessField, literal::Literal, Identifier, Optional, OptionalOperation, |
||||
OptionalOperationKind, |
||||
}, |
||||
Expression, Statement, |
||||
}, |
||||
parser::tests::{check_invalid, check_parser}, |
||||
}; |
||||
|
||||
#[test] |
||||
fn simple() { |
||||
let mut interner = Interner::default(); |
||||
|
||||
check_parser( |
||||
r#"5?.name"#, |
||||
vec![Statement::Expression( |
||||
Optional::new( |
||||
Literal::Int(5).into(), |
||||
vec![OptionalOperation::new( |
||||
OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const( |
||||
interner.get_or_intern_static("name", utf16!("name")), |
||||
), |
||||
}, |
||||
true, |
||||
)] |
||||
.into(), |
||||
) |
||||
.into(), |
||||
) |
||||
.into()], |
||||
interner, |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
fn complex_chain() { |
||||
let mut interner = Interner::default(); |
||||
|
||||
check_parser( |
||||
r#"a?.b(true)?.["c"]"#, |
||||
vec![Statement::Expression( |
||||
Optional::new( |
||||
Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), |
||||
vec![ |
||||
OptionalOperation::new( |
||||
OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Const( |
||||
interner.get_or_intern_static("b", utf16!("b")), |
||||
), |
||||
}, |
||||
true, |
||||
), |
||||
OptionalOperation::new( |
||||
OptionalOperationKind::Call { |
||||
args: vec![Expression::Literal(Literal::Bool(true))].into(), |
||||
}, |
||||
false, |
||||
), |
||||
OptionalOperation::new( |
||||
OptionalOperationKind::SimplePropertyAccess { |
||||
field: PropertyAccessField::Expr(Box::new( |
||||
Literal::String(interner.get_or_intern_static("c", utf16!("c"))) |
||||
.into(), |
||||
)), |
||||
}, |
||||
true, |
||||
), |
||||
] |
||||
.into(), |
||||
) |
||||
.into(), |
||||
) |
||||
.into()], |
||||
interner, |
||||
); |
||||
} |
||||
|
||||
#[test] |
||||
fn reject_templates() { |
||||
check_invalid("console.log?.`Hello`"); |
||||
check_invalid("console?.log`Hello`"); |
||||
check_invalid( |
||||
r#" |
||||
const a = console?.log |
||||
`Hello`"#, |
||||
); |
||||
} |
||||
Loading…
Reference in new issue