Implement Async Generator Parsing

boa/src/bytecompiler.rs

@@ -672,6 +672,38 @@ impl ByteCompiler {
                                         }
                                     }
                                 }
+                                MethodDefinitionKind::Async => {
+                                    // TODO: Implement async
+                                    self.emit_opcode(Opcode::PushUndefined);
+                                    self.emit_opcode(Opcode::Swap);
+                                    match name {
+                                        PropertyName::Literal(name) => {
+                                            let index = self.get_or_insert_name(name);
+                                            self.emit(Opcode::SetPropertyByName, &[index])
+                                        }
+                                        PropertyName::Computed(name_node) => {
+                                            self.compile_stmt(name_node, true);
+                                            self.emit_opcode(Opcode::Swap);
+                                            self.emit_opcode(Opcode::SetPropertyByValue);
+                                        }
+                                    }
+                                }
+                                MethodDefinitionKind::AsyncGenerator => {
+                                    // TODO: Implement async generators
+                                    self.emit_opcode(Opcode::PushUndefined);
+                                    self.emit_opcode(Opcode::Swap);
+                                    match name {
+                                        PropertyName::Literal(name) => {
+                                            let index = self.get_or_insert_name(name);
+                                            self.emit(Opcode::SetPropertyByName, &[index])
+                                        }
+                                        PropertyName::Computed(name_node) => {
+                                            self.compile_stmt(name_node, true);
+                                            self.emit_opcode(Opcode::Swap);
+                                            self.emit_opcode(Opcode::SetPropertyByValue);
+                                        }
+                                    }
+                                }
                             }
                         }
                         // TODO: Spread Object

boa/src/syntax/ast/node/declaration/async_generator_decl/mod.rs

@@ -0,0 +1,94 @@
+//! Async Generator Declaration
+
+use crate::{
+    exec::Executable,
+    syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
+    BoaProfiler, Context, JsResult, JsValue,
+};
+use gc::{Finalize, Trace};
+use std::fmt;
+
+#[cfg(feature = "deser")]
+use serde::{Deserialize, Serialize};
+
+/// The 'async function*' defines an async generator function
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///
+/// [spec]: https://tc39.es/ecma262/#prod-AsyncGeneratorMethod
+#[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
+#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
+pub struct AsyncGeneratorDecl {
+    name: Box<str>,
+    parameters: Box<[FormalParameter]>,
+    body: StatementList,
+}
+
+impl AsyncGeneratorDecl {
+    /// Creates a new async generator declaration.
+    pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
+    where
+        N: Into<Box<str>>,
+        P: Into<Box<[FormalParameter]>>,
+        B: Into<StatementList>,
+    {
+        Self {
+            name: name.into(),
+            parameters: parameters.into(),
+            body: body.into(),
+        }
+    }
+
+    /// Gets the name of the async function declaration.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Gets the list of parameters of the async function declaration.
+    pub fn parameters(&self) -> &[FormalParameter] {
+        &self.parameters
+    }
+
+    /// Gets the body of the async function declaration.
+    pub fn body(&self) -> &[Node] {
+        self.body.items()
+    }
+
+    /// Implements the display formatting with indentation.
+    pub(in crate::syntax::ast::node) fn display(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        indentation: usize,
+    ) -> fmt::Result {
+        write!(f, "async function* {}(", self.name())?;
+        join_nodes(f, &self.parameters)?;
+        if self.body().is_empty() {
+            f.write_str(") {}")
+        } else {
+            f.write_str(") {\n")?;
+            self.body.display(f, indentation + 1)?;
+            write!(f, "{}}}", "    ".repeat(indentation))
+        }
+    }
+}
+
+impl Executable for AsyncGeneratorDecl {
+    fn run(&self, _: &mut Context) -> JsResult<JsValue> {
+        let _timer = BoaProfiler::global().start_event("AsyncGeneratorDecl", "exec");
+        //TODO: Implement AsyncGeneratorDecl
+        Ok(JsValue::undefined())
+    }
+}
+
+impl From<AsyncGeneratorDecl> for Node {
+    fn from(decl: AsyncGeneratorDecl) -> Self {
+        Self::AsyncGeneratorDecl(decl)
+    }
+}
+
+impl fmt::Display for AsyncGeneratorDecl {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display(f, 0)
+    }
+}

boa/src/syntax/ast/node/declaration/async_generator_expr/mod.rs

@@ -0,0 +1,106 @@
+//! Async Generator Expression
+
+use crate::{
+    exec::Executable,
+    gc::{Finalize, Trace},
+    syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
+    Context, JsResult, JsValue,
+};
+use std::fmt;
+
+#[cfg(feature = "deser")]
+use serde::{Deserialize, Serialize};
+
+/// The `async function*` keyword can be used to define a generator function inside an expression.
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///
+/// [spec]: https://tc39.es/ecma262/#prod-AsyncGeneratorExpression
+
+#[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
+#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
+pub struct AsyncGeneratorExpr {
+    name: Option<Box<str>>,
+    parameters: Box<[FormalParameter]>,
+    body: StatementList,
+}
+
+impl AsyncGeneratorExpr {
+    /// Creates a new async generator expression
+    pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
+    where
+        N: Into<Option<Box<str>>>,
+        P: Into<Box<[FormalParameter]>>,
+        B: Into<StatementList>,
+    {
+        Self {
+            name: name.into(),
+            parameters: parameters.into(),
+            body: body.into(),
+        }
+    }
+
+    /// Gets the name of the async generator expression
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(Box::as_ref)
+    }
+
+    /// Gets the list of parameters of the async generator expression
+    pub fn parameters(&self) -> &[FormalParameter] {
+        &self.parameters
+    }
+
+    /// Gets the body of the async generator expression
+    pub fn body(&self) -> &StatementList {
+        &self.body
+    }
+
+    pub(in crate::syntax::ast::node) fn display(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        indentation: usize,
+    ) -> fmt::Result {
+        f.write_str("async function*")?;
+        if let Some(ref name) = self.name {
+            write!(f, " {}", name)?;
+        }
+        f.write_str("(")?;
+        join_nodes(f, &self.parameters)?;
+        f.write_str(") ")?;
+        self.display_block(f, indentation)
+    }
+
+    pub(in crate::syntax::ast::node) fn display_block(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        indentation: usize,
+    ) -> fmt::Result {
+        if self.body().items().is_empty() {
+            f.write_str("{}")
+        } else {
+            f.write_str("{\n")?;
+            self.body.display(f, indentation + 1)?;
+            write!(f, "{}}}", "    ".repeat(indentation))
+        }
+    }
+}
+
+impl Executable for AsyncGeneratorExpr {
+    fn run(&self, _context: &mut Context) -> JsResult<JsValue> {
+        //TODO: Implement AsyncGeneratorFunction
+        Ok(JsValue::undefined())
+    }
+}
+
+impl fmt::Display for AsyncGeneratorExpr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display(f, 0)
+    }
+}
+
+impl From<AsyncGeneratorExpr> for Node {
+    fn from(expr: AsyncGeneratorExpr) -> Self {
+        Self::AsyncGeneratorExpr(expr)
+    }
+}

boa/src/syntax/ast/node/declaration/mod.rs

@@ -15,14 +15,17 @@ use serde::{Deserialize, Serialize};
 pub mod arrow_function_decl;
 pub mod async_function_decl;
 pub mod async_function_expr;
+pub mod async_generator_decl;
+pub mod async_generator_expr;
 pub mod function_decl;
 pub mod function_expr;
 pub mod generator_decl;
 pub mod generator_expr;
 
 pub use self::{
     arrow_function_decl::ArrowFunctionDecl, async_function_decl::AsyncFunctionDecl,
-    async_function_expr::AsyncFunctionExpr, function_decl::FunctionDecl,
+    async_function_expr::AsyncFunctionExpr, async_generator_decl::AsyncGeneratorDecl,
+    async_generator_expr::AsyncGeneratorExpr, function_decl::FunctionDecl,
     function_expr::FunctionExpr,
 };
 

boa/src/syntax/ast/node/mod.rs

@@ -30,6 +30,7 @@ pub use self::{
     call::Call,
     conditional::{ConditionalOp, If},
     declaration::{
+        async_generator_decl::AsyncGeneratorDecl, async_generator_expr::AsyncGeneratorExpr,
         generator_decl::GeneratorDecl, generator_expr::GeneratorExpr, ArrowFunctionDecl,
         AsyncFunctionDecl, AsyncFunctionExpr, Declaration, DeclarationList, FunctionDecl,
         FunctionExpr,
@@ -82,6 +83,12 @@ pub enum Node {
     /// An async function expression node. [More information](./declaration/struct.AsyncFunctionExpr.html).
     AsyncFunctionExpr(AsyncFunctionExpr),
 
+    /// An async generator expression node.
+    AsyncGeneratorExpr(AsyncGeneratorExpr),
+
+    /// An async generator declaration node.
+    AsyncGeneratorDecl(AsyncGeneratorDecl),
+
     /// An await expression node. [More information](./await_expr/struct.AwaitExpression.html).
     AwaitExpr(AwaitExpr),
 
@@ -317,6 +324,8 @@ impl Node {
             Self::Yield(ref y) => Display::fmt(y, f),
             Self::GeneratorDecl(ref decl) => Display::fmt(decl, f),
             Self::GeneratorExpr(ref expr) => expr.display(f, indentation),
+            Self::AsyncGeneratorExpr(ref expr) => expr.display(f, indentation),
+            Self::AsyncGeneratorDecl(ref decl) => decl.display(f, indentation),
         }
     }
 }
@@ -327,6 +336,8 @@ impl Executable for Node {
         match *self {
             Node::AsyncFunctionDecl(ref decl) => decl.run(context),
             Node::AsyncFunctionExpr(ref function_expr) => function_expr.run(context),
+            Node::AsyncGeneratorExpr(ref expr) => expr.run(context),
+            Node::AsyncGeneratorDecl(ref decl) => decl.run(context),
             Node::AwaitExpr(ref expr) => expr.run(context),
             Node::Call(ref call) => call.run(context),
             Node::Const(Const::Null) => Ok(JsValue::null()),
@@ -625,6 +636,26 @@ pub enum MethodDefinitionKind {
     /// [spec]: https://tc39.es/ecma262/#prod-MethodDefinition
     /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#generator_methods
     Generator,
+
+    /// Async generators can be used to define a method
+    ///
+    /// More information
+    ///  - [ECMAScript reference][spec]
+    ///  - [MDN documentation][mdn]
+    ///
+    /// [spec]: https://tc39.es/ecma262/#prod-AsyncGeneratorMethod
+    /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#async_generator_methods
+    AsyncGenerator,
+
+    /// Async function can be used to define a method
+    ///
+    /// More information
+    ///  - [ECMAScript reference][spec]
+    ///  - [MDN documentation][mdn]
+    ///
+    /// [spec]: https://tc39.es/ecma262/#prod-AsyncMethod
+    /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions#async_methods
+    Async,
 }
 
 unsafe impl Trace for MethodDefinitionKind {

boa/src/syntax/ast/node/object/mod.rs

@@ -72,7 +72,10 @@ impl Object {
                     match &kind {
                         MethodDefinitionKind::Get => write!(f, "get ")?,
                         MethodDefinitionKind::Set => write!(f, "set ")?,
-                        MethodDefinitionKind::Ordinary | MethodDefinitionKind::Generator => (),
+                        MethodDefinitionKind::Ordinary
+                        | MethodDefinitionKind::Generator
+                        | MethodDefinitionKind::Async
+                        | MethodDefinitionKind::AsyncGenerator => (),
                     }
                     write!(f, "{}(", key)?;
                     join_nodes(f, node.parameters())?;
@@ -179,6 +182,31 @@ impl Executable for Object {
                                 context,
                             )?;
                         }
+                        &MethodDefinitionKind::AsyncGenerator => {
+                            // TODO: Implement async generator method definition execution.
+                            obj.__define_own_property__(
+                                name,
+                                PropertyDescriptor::builder()
+                                    .value(JsValue::undefined())
+                                    .writable(true)
+                                    .enumerable(true)
+                                    .configurable(true)
+                                    .build(),
+                                context,
+                            )?;
+                        }
+                        &MethodDefinitionKind::Async => {
+                            obj.__define_own_property__(
+                                name,
+                                PropertyDescriptor::builder()
+                                    .value(JsValue::undefined())
+                                    .writable(true)
+                                    .enumerable(true)
+                                    .configurable(true)
+                                    .build(),
+                                context,
+                            )?;
+                        }
                     }
                 }
                 // [spec]: https://tc39.es/ecma262/#sec-runtime-semantics-propertydefinitionevaluation