Garbage-collect expression ASTs

In parse_and_visit_expression, we know that an allocated expression
isn't used after calling visit_expression. Save memory by deleting the
entire expression tree allocated by parse_expression after calling
visit_expression.

This commit should not change behavior.

This memory usage optimization improves parsing performance:

      --------------------------------------------------------------------------
      When       Benchmark                     Time             CPU   Iterations
      --------------------------------------------------------------------------
      before     benchmark_parse_file    1634589 ns      1632770 ns         1710
      after      benchmark_parse_file    1621339 ns      1619349 ns         1747

Author: strager

src/quick-lint-js/expression.h

@@ -130,6 +130,8 @@ class expression_arena {
     return &this->buffering_visitor_memory_;
   }
 
+  monotonic_allocator *allocator() noexcept { return &this->allocator_; }
+
  private:
   template <class T, class... Args>
   T *allocate(Args &&... args) {

src/quick-lint-js/linked-bump-allocator.h

@@ -17,6 +17,12 @@
 #include <sanitizer/asan_interface.h>
 #endif
 
+#if defined(QLJS_DEBUG) && QLJS_DEBUG
+#define QLJS_DEBUG_BUMP_ALLOCATOR 1
+#else
+#define QLJS_DEBUG_BUMP_ALLOCATOR 0
+#endif
+
 namespace quick_lint_js {
 // A memory allocator with a few features:
 //
@@ -121,6 +127,7 @@ class linked_bump_allocator : public boost::container::pmr::memory_resource {
   template <class T>
   bool try_grow_array_in_place(T* array, std::size_t old_size,
                                std::size_t new_size) {
+    this->assert_not_disabled();
     QLJS_ASSERT(new_size > old_size);
     std::size_t old_byte_size = this->align_up(old_size * sizeof(T));
     bool array_is_last_allocation =
@@ -156,6 +163,33 @@ class linked_bump_allocator : public boost::container::pmr::memory_resource {
     return this;
   }
 
+  class disable_guard {
+   public:
+    ~disable_guard() {
+#if QLJS_DEBUG_BUMP_ALLOCATOR
+      this->alloc_->disabled_count_ -= 1;
+#endif
+    }
+
+   private:
+#if QLJS_DEBUG_BUMP_ALLOCATOR
+    explicit disable_guard(linked_bump_allocator* alloc) noexcept
+        : alloc_(alloc) {
+      this->alloc_->disabled_count_ -= 1;
+    }
+#else
+    explicit disable_guard(linked_bump_allocator*) noexcept {}
+#endif
+
+#if QLJS_DEBUG_BUMP_ALLOCATOR
+    linked_bump_allocator* alloc_;
+#endif
+
+    friend class linked_bump_allocator;
+  };
+
+  [[nodiscard]] disable_guard disable() noexcept { return disable_guard(this); }
+
  protected:
   void* do_allocate(std::size_t bytes, std::size_t align) override {
     QLJS_ASSERT(align <= Alignment);
@@ -230,6 +264,7 @@ class linked_bump_allocator : public boost::container::pmr::memory_resource {
 #endif
 
   [[nodiscard]] void* allocate_bytes(std::size_t size) {
+    this->assert_not_disabled();
     QLJS_SLOW_ASSERT(size % Alignment == 0);
     if (this->remaining_bytes_in_current_chunk() < size) {
       this->append_chunk(maximum(size, this->default_chunk_size));
@@ -268,9 +303,23 @@ class linked_bump_allocator : public boost::container::pmr::memory_resource {
     this->chunk_end_ = this->chunk_->data_end();
   }
 
+  void assert_not_disabled() const {
+#if QLJS_DEBUG_BUMP_ALLOCATOR
+    QLJS_ALWAYS_ASSERT(!this->is_disabled());
+#endif
+  }
+
+#if QLJS_DEBUG_BUMP_ALLOCATOR
+  bool is_disabled() const noexcept { return this->disabled_count_ > 0; }
+#endif
+
   chunk_header* chunk_ = nullptr;
   char* next_allocation_ = nullptr;
   char* chunk_end_ = nullptr;
+
+#if QLJS_DEBUG_BUMP_ALLOCATOR
+  int disabled_count_ = 0;
+#endif
 };
 }
 

src/quick-lint-js/parse.h

@@ -3673,8 +3673,16 @@ class parser {
 
   template <QLJS_PARSE_VISITOR Visitor>
   void parse_and_visit_expression(Visitor &v, precedence prec) {
+    monotonic_allocator &alloc = *this->expressions_.allocator();
+    auto rewind_state = alloc.prepare_for_rewind();
+
     expression *ast = this->parse_expression(prec);
-    this->visit_expression(ast, v, variable_context::rhs);
+    {
+      auto disable_guard = alloc.disable();
+      this->visit_expression(ast, v, variable_context::rhs);
+    }
+
+    alloc.rewind(std::move(rewind_state));
   }
 
   expression *parse_expression(precedence);