Suggest fix for mispelled await inside async function

Fix for issue #279.

Author: keyehzy

src/parse.cpp

@@ -837,10 +837,16 @@ expression* parser::parse_await_expression(token await_token, precedence prec) {
     }
 
     expression* child = this->parse_expression(prec);
+
     if (child->kind() == expression_kind::_invalid) {
       this->error_reporter_->report(error_missing_operand_for_operator{
           .where = operator_span,
       });
+    } else if (this->in_async_function_ && this->is_arrow_kind(child) &&
+               child->attributes() != function_attributes::async) {
+      this->error_reporter_->report(error_await_followed_by_arrow_function{
+          .await_operator = operator_span,
+      });
     }
     return this->make_expression<expression::await>(child, operator_span);
   }
@@ -2258,6 +2264,11 @@ void parser::consume_semicolon() {
   }
 }
 
+bool parser::is_arrow_kind(expression* ast) noexcept {
+  return ast->kind() == expression_kind::arrow_function_with_statements ||
+         ast->kind() == expression_kind::arrow_function_with_expression;
+}
+
 void parser::crash_on_unimplemented_token(const char* qljs_file_name,
                                           int qljs_line,
                                           const char* qljs_function_name) {

src/quick-lint-js/error.h

@@ -88,6 +88,13 @@
       ERROR(QLJS_TRANSLATABLE("'await' is only allowed in async functions"),   \
             await_operator))                                                   \
                                                                                \
+  QLJS_ERROR_TYPE(                                                             \
+      error_await_followed_by_arrow_function, "E178",                          \
+      { source_code_span await_operator; },                                    \
+      ERROR(QLJS_TRANSLATABLE("'await' cannot be followed by an arrow "        \
+                              "function; use 'async' instead"),                \
+            await_operator))                                                   \
+                                                                               \
   QLJS_ERROR_TYPE(                                                             \
       error_async_static_method, "E269", { source_code_span async_static; },   \
       ERROR(                                                                   \

src/quick-lint-js/parse.h

@@ -3686,6 +3686,8 @@ class parser {
   expression *maybe_wrap_erroneous_arrow_function(expression *arrow_function,
                                                   expression *lhs);
 
+  bool is_arrow_kind(expression *ast) noexcept;
+
   void consume_semicolon();
 
   const token &peek() const noexcept { return this->lexer_.peek(); }

test/test-parse-expression.cpp

@@ -925,6 +925,34 @@ TEST_F(test_parse_expression, await_unary_operator_inside_async_functions) {
   }
 }
 
+TEST_F(test_parse_expression, await_followed_by_arrow_function) {
+  {
+    test_parser p(u8"await x => {}"_sv);
+    auto guard = p.parser().enter_function(function_attributes::async);
+    expression* ast = p.parse_expression();
+    EXPECT_EQ(ast->kind(), expression_kind::await);
+    EXPECT_EQ(ast->child_0()->kind(),
+              expression_kind::arrow_function_with_statements);
+    EXPECT_THAT(p.errors(),
+                ElementsAre(ERROR_TYPE_FIELD(
+                    error_await_followed_by_arrow_function, await_operator,
+                    offsets_matcher(p.code(), 0, u8"await"))));
+  }
+
+  {
+    test_parser p(u8"await () => {}"_sv);
+    auto guard = p.parser().enter_function(function_attributes::async);
+    expression* ast = p.parse_expression();
+    EXPECT_EQ(ast->kind(), expression_kind::await);
+    EXPECT_EQ(ast->child_0()->kind(),
+              expression_kind::arrow_function_with_statements);
+    EXPECT_THAT(p.errors(),
+                ElementsAre(ERROR_TYPE_FIELD(
+                    error_await_followed_by_arrow_function, await_operator,
+                    offsets_matcher(p.code(), 0, u8"await"))));
+  }
+}
+
 TEST_F(test_parse_expression,
        await_in_normal_function_vs_async_function_vs_top_level) {
   struct test_case {