From 970534e03e7415080fbd2190058102fdccd92efe Mon Sep 17 00:00:00 2001
From: Paul <pl59@st-andrews.ac.uk>
Date: Tue, 12 Jan 2021 23:04:23 +0000
Subject: [PATCH] Add async arrow tests

---
 .../mod.rs}                                   |  2 +
 .../assignment/async_arrow_function/tests.rs  | 72 +++++++++++++++++++
 .../parser/expression/assignment/mod.rs       |  6 +-
 .../syntax/parser/expression/primary/mod.rs   | 14 +++-
 4 files changed, 90 insertions(+), 4 deletions(-)
 rename boa/src/syntax/parser/expression/assignment/{async_arrow_function.rs => async_arrow_function/mod.rs} (99%)
 create mode 100644 boa/src/syntax/parser/expression/assignment/async_arrow_function/tests.rs

diff --git a/boa/src/syntax/parser/expression/assignment/async_arrow_function.rs b/boa/src/syntax/parser/expression/assignment/async_arrow_function/mod.rs
similarity index 99%
rename from boa/src/syntax/parser/expression/assignment/async_arrow_function.rs
rename to boa/src/syntax/parser/expression/assignment/async_arrow_function/mod.rs
index 975f424bf9f..ec9bf2dd3dd 100644
--- a/boa/src/syntax/parser/expression/assignment/async_arrow_function.rs
+++ b/boa/src/syntax/parser/expression/assignment/async_arrow_function/mod.rs
@@ -6,6 +6,8 @@
 //!
 //! [mdn]:
 //! [spec]: https://tc39.es/ecma262/#prod-AsyncArrowFunction
+#[cfg(test)]
+mod tests;
 
 use super::ConciseBody;
 use crate::{
diff --git a/boa/src/syntax/parser/expression/assignment/async_arrow_function/tests.rs b/boa/src/syntax/parser/expression/assignment/async_arrow_function/tests.rs
new file mode 100644
index 00000000000..98197d531f1
--- /dev/null
+++ b/boa/src/syntax/parser/expression/assignment/async_arrow_function/tests.rs
@@ -0,0 +1,72 @@
+use crate::syntax::{
+    ast::node::{
+        AsyncArrowFunctionDecl, BinOp, FormalParameter, Identifier, LetDecl, LetDeclList, Node,
+        Return,
+    },
+    ast::op::NumOp,
+    parser::tests::check_parser,
+};
+
+/// Checks an arrow function with expression return.
+#[test]
+fn check_async_arrow() {
+    check_parser(
+        "async (a, b) => { return a + b; }",
+        vec![AsyncArrowFunctionDecl::new(
+            vec![
+                FormalParameter::new("a", None, false),
+                FormalParameter::new("b", None, false),
+            ],
+            vec![Return::new(
+                BinOp::new(NumOp::Add, Identifier::from("a"), Identifier::from("b")),
+                None,
+            )
+            .into()],
+        )
+        .into()],
+    );
+}
+
+#[test]
+fn check_async_arrow_assignment() {
+    check_parser(
+        "let foo = async (a) => { return a };",
+        vec![LetDeclList::from(vec![LetDecl::new::<_, Option<Node>>(
+            Identifier::from("foo"),
+            Some(
+                AsyncArrowFunctionDecl::new(
+                    vec![FormalParameter::new("a", None, false)],
+                    vec![Return::new::<Node, Option<_>, Option<_>>(
+                        Some(Identifier::from("a").into()),
+                        None,
+                    )
+                    .into()],
+                )
+                .into(),
+            ),
+        )])
+        .into()],
+    );
+}
+
+#[test]
+fn check_async_arrow_assignment_noparenthesis() {
+    check_parser(
+        "let foo = async a => { return a };",
+        vec![LetDeclList::from(vec![LetDecl::new::<_, Option<Node>>(
+            Identifier::from("foo"),
+            Some(
+                AsyncArrowFunctionDecl::new(
+                    vec![FormalParameter::new("a", None, false)],
+                    vec![Return::new::<Node, Option<_>, Option<_>>(
+                        Some(Identifier::from("a").into()),
+                        None,
+                    )
+                    .into()],
+                )
+                .into(),
+            ),
+        )])
+        .into()],
+    );
+}
diff --git a/boa/src/syntax/parser/expression/assignment/mod.rs b/boa/src/syntax/parser/expression/assignment/mod.rs
index 91096ee0a8f..64a407508f0 100644
--- a/boa/src/syntax/parser/expression/assignment/mod.rs
+++ b/boa/src/syntax/parser/expression/assignment/mod.rs
@@ -88,6 +88,7 @@ where
         let _timer = BoaProfiler::global().start_event("AssignmentExpression", "Parsing");
         cursor.set_goal(InputElement::Div);
 
+        println!("Assignment expression");
         // Arrow function
         match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
             // Async a => {} or Async function or Async (a) => {}
@@ -104,9 +105,12 @@ where
                             .map(Node::AsyncArrowFunctionDecl);
                         }
                         TokenKind::Punctuator(Punctuator::OpenParen) => {
+                            println!("OpenParen");
                             todo!("Async arrow func with () params");
                         }
-                        _ => {}
+                        _ => {
+                            println!("Async not open Paren / Identifier");
+                        }
                     }
                 }
             }
diff --git a/boa/src/syntax/parser/expression/primary/mod.rs b/boa/src/syntax/parser/expression/primary/mod.rs
index 16183f002ec..57db07fffba 100644
--- a/boa/src/syntax/parser/expression/primary/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/mod.rs
@@ -82,9 +82,17 @@ where
             TokenKind::Keyword(Keyword::Function) => {
                 FunctionExpression.parse(cursor).map(Node::from)
             }
-            TokenKind::Keyword(Keyword::Async) => AsyncFunctionExpression::new(self.allow_yield)
-                .parse(cursor)
-                .map(Node::from),
+            TokenKind::Keyword(Keyword::Async) => {
+                println!("Keyword async");
+                match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    TokenKind::Keyword(Keyword::Function) => {
+                        AsyncFunctionExpression::new(self.allow_yield)
+                            .parse(cursor)
+                            .map(Node::from)
+                    }
+                    _ => Err(ParseError::unexpected(tok.clone(), "primary expression")),
+                }
+            }
             TokenKind::Punctuator(Punctuator::OpenParen) => {
                 cursor.set_goal(InputElement::RegExp);
                 let expr =