Fix quadratic time and space when parsing 'await/'

Pathalogical code can cause quick-lint-js to consume tons of memory and
tons of time. The root cause is infinite lookahead (implemented as backtracking) which occurs when parsing code like the following:

    function f() {
      await/
      ()=>{{{{{{{await/
      ()=>{{{{{{{await/
      ()=>{{{{{{{await/
      ()=>{{{{{{{await/
      ()=>{{{{{{{await/
    }

quick-lint-js' algorithm for determining whether 'await' is supposed to
be an identifier or an operator parses what follows speculatively.
Because the speculative parse can parse an arbitrary amount of code,
and speculative parses can be nested, we end up with quadratic behavior.

Cache 'await' guesses to turn the quadratic behavior into linear
behavior.

This code should improve performance for pathalogical cases without
changing behavior.

Author: strager

src/parse.cpp

@@ -711,6 +711,21 @@ expression* parser::parse_await_expression(token await_token, precedence prec) {
       // await / rhs;
       case token_type::slash:
       case token_type::slash_equal: {
+        parse_expression_cache_key cache_key = {
+            .begin = this->peek().begin,
+            .in_top_level = this->in_top_level_,
+            .in_async_function = this->in_async_function_,
+            .in_generator_function = this->in_generator_function_,
+            .in_loop_statement = this->in_loop_statement_,
+            .in_switch_statement = this->in_switch_statement_,
+            .in_class = this->in_class_,
+        };
+        auto cache_it =
+            this->await_slash_is_identifier_divide_cache_.find(cache_key);
+        if (cache_it != this->await_slash_is_identifier_divide_cache_.end()) {
+          return cache_it->second;
+        }
+
         buffering_error_reporter temp_error_reporter(&this->temporary_memory_);
         error_reporter* old_error_reporter =
             std::exchange(this->error_reporter_, &temp_error_reporter);
@@ -732,13 +747,19 @@ expression* parser::parse_await_expression(token await_token, precedence prec) {
         this->lexer_.roll_back_transaction(std::move(transaction));
         this->error_reporter_ = old_error_reporter;
 
+        bool is_identifier_result;
         if (this->in_top_level_) {
           bool parsed_slash_as_regexp = parsed_ok;
-          return !parsed_slash_as_regexp;
+          is_identifier_result = !parsed_slash_as_regexp;
         } else {
           bool parsed_slash_as_divide = parsed_ok;
-          return parsed_slash_as_divide;
+          is_identifier_result = parsed_slash_as_divide;
         }
+        auto [_cache_it, inserted] =
+            this->await_slash_is_identifier_divide_cache_.try_emplace(
+                cache_key, is_identifier_result);
+        QLJS_ASSERT(inserted);
+        return is_identifier_result;
       }
 
       case token_type::kw_of:
@@ -2275,6 +2296,26 @@ parser::function_guard::~function_guard() noexcept {
   this->parser_->in_loop_statement_ = this->was_in_loop_statement_;
   this->parser_->in_switch_statement_ = this->was_in_switch_statement_;
 }
+
+bool parser::parse_expression_cache_key::operator==(
+    const parser::parse_expression_cache_key& rhs) const noexcept {
+  return this->begin == rhs.begin && this->in_top_level == rhs.in_top_level &&
+         this->in_async_function == rhs.in_async_function &&
+         this->in_generator_function == rhs.in_generator_function &&
+         this->in_loop_statement == rhs.in_loop_statement &&
+         this->in_switch_statement == rhs.in_switch_statement &&
+         this->in_class == rhs.in_class;
+}
+
+bool parser::parse_expression_cache_key::operator!=(
+    const parser::parse_expression_cache_key& rhs) const noexcept {
+  return !(*this == rhs);
+}
+
+std::size_t parser::parse_expression_cache_key::hash::operator()(
+    const parse_expression_cache_key& x) const noexcept {
+  return std::hash<const char8*>()(x.begin);
+}
 }
 
 // quick-lint-js finds bugs in JavaScript programs.

src/quick-lint-js/parse.h

@@ -21,6 +21,7 @@
 #include <quick-lint-js/parse-visitor.h>
 #include <quick-lint-js/token.h>
 #include <quick-lint-js/warning.h>
+#include <unordered_map>
 #include <utility>
 
 #if QLJS_HAVE_SETJMP
@@ -3712,6 +3713,23 @@ class parser {
     int old_depth_;
   };
 
+  struct parse_expression_cache_key {
+    const char8 *begin;
+    bool in_top_level;
+    bool in_async_function;
+    bool in_generator_function;
+    bool in_loop_statement;
+    bool in_switch_statement;
+    bool in_class;
+
+    bool operator==(const parse_expression_cache_key &rhs) const noexcept;
+    bool operator!=(const parse_expression_cache_key &rhs) const noexcept;
+
+    struct hash {
+      std::size_t operator()(const parse_expression_cache_key &) const noexcept;
+    };
+  };
+
   quick_lint_js::lexer lexer_;
   error_reporter *error_reporter_;
   quick_lint_js::expression_arena expressions_;
@@ -3730,6 +3748,23 @@ class parser {
   bool in_switch_statement_ = false;
   bool in_class_ = false;
 
+  // Cache of whether 'await' is an identifier or an operator. This cache is
+  // used to avoid quadratic run-time in code like the following:
+  //
+  //   await / await / await / await / await
+  //
+  // (In `await/await`, `await` is an identifier. But in `await/await/`, the
+  // first `await` is an operator.)
+  //
+  // The value of each entry indicates the conclusion:
+  // * true means 'await' looks like an identifier, thus '/' is the division
+  //   operator.
+  // * false means 'await' looks like an operator, thus '/' begins a regular
+  //   expression literal.
+  std::unordered_map<parse_expression_cache_key, bool,
+                     parse_expression_cache_key::hash>
+      await_slash_is_identifier_divide_cache_;
+
 #if QLJS_HAVE_SETJMP
   bool have_fatal_parse_error_jmp_buf_ = false;
   std::jmp_buf fatal_parse_error_jmp_buf_;