[cleanup] Split src/zone/zone.h header

... into
  src/zone/scoped-list.h
  src/zone/zone-hashmap.h
  src/zone/zone-list.h
  src/zone/zone-fwd.h

zone-fwd.h header contains zone-related forward type declarations.

Bug: v8:10506
Change-Id: Ic61b6717b3034afa24bdd49fbc0ce758a0e93c75
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2284987
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Cr-Commit-Position: refs/heads/master@{#68734}

BUILD.gn

@@ -3241,11 +3241,15 @@ v8_source_set("v8_base_without_compiler") {
     "src/wasm/wasm-value.h",
     "src/zone/accounting-allocator.cc",
     "src/zone/accounting-allocator.h",
+    "src/zone/scoped-list.h",
     "src/zone/zone-allocator.h",
     "src/zone/zone-chunk-list.h",
     "src/zone/zone-containers.h",
+    "src/zone/zone-fwd.h",
     "src/zone/zone-handle-set.h",
+    "src/zone/zone-hashmap.h",
     "src/zone/zone-list-inl.h",
+    "src/zone/zone-list.h",
     "src/zone/zone-segment.cc",
     "src/zone/zone-segment.h",
     "src/zone/zone.cc",

src/ast/ast.h

@@ -21,6 +21,7 @@
 #include "src/objects/smi.h"
 #include "src/parsing/token.h"
 #include "src/runtime/runtime.h"
+#include "src/zone/zone-list.h"
 
 namespace v8 {
 namespace internal {

src/ast/scopes.h

@@ -6,6 +6,7 @@
 #define V8_AST_SCOPES_H_
 
 #include <numeric>
+
 #include "src/ast/ast.h"
 #include "src/base/compiler-specific.h"
 #include "src/base/hashmap.h"
@@ -15,6 +16,7 @@
 #include "src/objects/objects.h"
 #include "src/utils/pointer-with-payload.h"
 #include "src/utils/utils.h"
+#include "src/zone/zone-hashmap.h"
 #include "src/zone/zone.h"
 
 namespace v8 {

src/codegen/compilation-cache.h

@@ -5,6 +5,7 @@
 #ifndef V8_CODEGEN_COMPILATION_CACHE_H_
 #define V8_CODEGEN_COMPILATION_CACHE_H_
 
+#include "src/base/hashmap.h"
 #include "src/objects/compilation-cache.h"
 #include "src/utils/allocation.h"
 

src/compiler/state-values-utils.h

@@ -10,6 +10,7 @@
 #include "src/common/globals.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/js-graph.h"
+#include "src/zone/zone-hashmap.h"
 
 namespace v8 {
 namespace internal {

src/diagnostics/gdb-jit.cc

@@ -10,6 +10,7 @@
 
 #include "src/api/api-inl.h"
 #include "src/base/bits.h"
+#include "src/base/hashmap.h"
 #include "src/base/platform/platform.h"
 #include "src/execution/frames-inl.h"
 #include "src/execution/frames.h"

src/execution/simulator-base.h

@@ -7,6 +7,7 @@
 
 #include <type_traits>
 
+#include "src/base/hashmap.h"
 #include "src/common/globals.h"
 #include "src/execution/isolate.h"
 

src/init/bootstrapper.cc

@@ -6,6 +6,7 @@
 
 #include "src/api/api-inl.h"
 #include "src/api/api-natives.h"
+#include "src/base/hashmap.h"
 #include "src/base/ieee754.h"
 #include "src/builtins/accessors.h"
 #include "src/codegen/compiler.h"
@@ -59,6 +60,7 @@
 #include "src/objects/templates.h"
 #include "src/snapshot/snapshot.h"
 #include "src/wasm/wasm-js.h"
+#include "src/zone/zone-hashmap.h"
 
 namespace v8 {
 namespace internal {

src/objects/keys.cc

@@ -18,6 +18,7 @@
 #include "src/objects/property-descriptor.h"
 #include "src/objects/prototype.h"
 #include "src/utils/identity-map.h"
+#include "src/zone/zone-hashmap.h"
 
 namespace v8 {
 namespace internal {

src/parsing/preparse-data.h

@@ -11,6 +11,7 @@
 #include "src/handles/handles.h"
 #include "src/handles/maybe-handles.h"
 #include "src/utils/vector.h"
+#include "src/zone/scoped-list.h"
 #include "src/zone/zone-chunk-list.h"
 #include "src/zone/zone-containers.h"
 

src/parsing/rewriter.h

@@ -7,7 +7,7 @@
 
 #include "src/base/macros.h"
 #include "src/base/optional.h"
-#include "src/zone/zone.h"
+#include "src/zone/zone-fwd.h"
 
 namespace v8 {
 namespace internal {

src/regexp/regexp-ast.h

@@ -10,6 +10,7 @@
 #include "src/objects/string.h"
 #include "src/utils/utils.h"
 #include "src/zone/zone-containers.h"
+#include "src/zone/zone-list.h"
 #include "src/zone/zone.h"
 
 namespace v8 {

src/zone/scoped-list.h

+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_ZONE_SCOPED_LIST_H_
+#define V8_ZONE_SCOPED_LIST_H_
+
+#include <type_traits>
+#include <vector>
+
+#include "src/base/logging.h"
+#include "src/zone/zone.h"
+
+namespace v8 {
+namespace internal {
+
+template <typename T>
+class Vector;
+
+template <typename T>
+class ZoneList;
+
+// ScopedList is a scope-lifetime list with a std::vector backing that can be
+// re-used between ScopedLists. Note that a ScopedList in an outer scope cannot
+// add any entries if there is a ScopedList with the same backing in an inner
+// scope.
+//
+// TODO(ishell): move header to src/utils/ once zone dependency is resolved.
+template <typename T, typename TBacking = T>
+class ScopedList final {
+  // The backing can either be the same type as the list type, or, for pointers,
+  // we additionally allow a void* backing store.
+  STATIC_ASSERT((std::is_same<TBacking, T>::value) ||
+                (std::is_same<TBacking, void*>::value &&
+                 std::is_pointer<T>::value));
+
+ public:
+  explicit ScopedList(std::vector<TBacking>* buffer)
+      : buffer_(*buffer), start_(buffer->size()), end_(buffer->size()) {}
+
+  ~ScopedList() { Rewind(); }
+
+  void Rewind() {
+    DCHECK_EQ(buffer_.size(), end_);
+    buffer_.resize(start_);
+    end_ = start_;
+  }
+
+  void MergeInto(ScopedList* parent) {
+    DCHECK_EQ(parent->end_, start_);
+    parent->end_ = end_;
+    start_ = end_;
+    DCHECK_EQ(0, length());
+  }
+
+  int length() const { return static_cast<int>(end_ - start_); }
+
+  const T& at(int i) const {
+    size_t index = start_ + i;
+    DCHECK_LE(start_, index);
+    DCHECK_LT(index, buffer_.size());
+    return *reinterpret_cast<T*>(&buffer_[index]);
+  }
+
+  T& at(int i) {
+    size_t index = start_ + i;
+    DCHECK_LE(start_, index);
+    DCHECK_LT(index, buffer_.size());
+    return *reinterpret_cast<T*>(&buffer_[index]);
+  }
+
+  void CopyTo(ZoneList<T>* target, Zone* zone) const {
+    DCHECK_LE(end_, buffer_.size());
+    // Make sure we don't reference absent elements below.
+    if (length() == 0) return;
+    target->Initialize(length(), zone);
+    T* data = reinterpret_cast<T*>(&buffer_[start_]);
+    target->AddAll(Vector<T>(data, length()), zone);
+  }
+
+  Vector<T> CopyTo(Zone* zone) {
+    DCHECK_LE(end_, buffer_.size());
+    T* data = zone->NewArray<T>(length());
+    if (length() != 0) {
+      MemCopy(data, &buffer_[start_], length() * sizeof(T));
+    }
+    return Vector<T>(data, length());
+  }
+
+  void Add(const T& value) {
+    DCHECK_EQ(buffer_.size(), end_);
+    buffer_.push_back(value);
+    ++end_;
+  }
+
+  void AddAll(const ZoneList<T>& list) {
+    DCHECK_EQ(buffer_.size(), end_);
+    buffer_.reserve(buffer_.size() + list.length());
+    for (int i = 0; i < list.length(); i++) {
+      buffer_.push_back(list.at(i));
+    }
+    end_ += list.length();
+  }
+
+  using iterator = T*;
+  inline iterator begin() const {
+    return reinterpret_cast<T*>(buffer_.data() + start_);
+  }
+  inline iterator end() const {
+    return reinterpret_cast<T*>(buffer_.data() + end_);
+  }
+
+ private:
+  std::vector<TBacking>& buffer_;
+  size_t start_;
+  size_t end_;
+};
+
+template <typename T>
+using ScopedPtrList = ScopedList<T*, void*>;
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_ZONE_SCOPED_LIST_H_

src/zone/zone-fwd.h

+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_ZONE_ZONE_FWD_H_
+#define V8_ZONE_ZONE_FWD_H_
+
+namespace v8 {
+namespace internal {
+
+//
+// This header contains forward declarations for Zone-related objects and
+// containers.
+//
+
+class Zone;
+
+template <typename T>
+class ZoneList;
+
+// ZonePtrList is a ZoneList of pointers to ZoneObjects allocated in the same
+// zone as the list object.
+template <typename T>
+using ZonePtrList = ZoneList<T*>;
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_ZONE_ZONE_FWD_H_

src/zone/zone-hashmap.h

+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_ZONE_ZONE_HASHMAP_H_
+#define V8_ZONE_ZONE_HASHMAP_H_
+
+#include "src/base/hashmap.h"
+#include "src/zone/zone.h"
+
+namespace v8 {
+namespace internal {
+
+using ZoneHashMap = base::PointerTemplateHashMapImpl<ZoneAllocationPolicy>;
+
+using CustomMatcherZoneHashMap =
+    base::CustomMatcherTemplateHashMapImpl<ZoneAllocationPolicy>;
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_ZONE_ZONE_HASHMAP_H_

src/zone/zone-list-inl.h

@@ -5,11 +5,10 @@
 #ifndef V8_ZONE_ZONE_LIST_INL_H_
 #define V8_ZONE_ZONE_LIST_INL_H_
 
-#include "src/zone/zone.h"
-
 #include "src/base/macros.h"
 #include "src/base/platform/platform.h"
 #include "src/utils/memcopy.h"
+#include "src/zone/zone-list.h"
 
 namespace v8 {
 namespace internal {

src/zone/zone-list.h

+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_ZONE_ZONE_LIST_H_
+#define V8_ZONE_ZONE_LIST_H_
+
+#include <initializer_list>
+
+#include "src/base/logging.h"
+#include "src/zone/zone-fwd.h"
+#include "src/zone/zone.h"
+
+namespace v8 {
+namespace internal {
+
+template <typename T>
+class Vector;
+
+// ZoneLists are growable lists with constant-time access to the
+// elements. The list itself and all its elements are allocated in the
+// Zone. ZoneLists cannot be deleted individually; you can delete all
+// objects in the Zone by calling Zone::DeleteAll().
+template <typename T>
+class ZoneList final {
+ public:
+  // Construct a new ZoneList with the given capacity; the length is
+  // always zero. The capacity must be non-negative.
+  ZoneList(int capacity, Zone* zone) { Initialize(capacity, zone); }
+  // Construct a new ZoneList from a std::initializer_list
+  ZoneList(std::initializer_list<T> list, Zone* zone) {
+    Initialize(static_cast<int>(list.size()), zone);
+    for (auto& i : list) Add(i, zone);
+  }
+  // Construct a new ZoneList by copying the elements of the given ZoneList.
+  ZoneList(const ZoneList<T>& other, Zone* zone) {
+    Initialize(other.length(), zone);
+    AddAll(other, zone);
+  }
+
+  V8_INLINE ~ZoneList() { DeleteData(data_); }
+
+  // Please the MSVC compiler.  We should never have to execute this.
+  V8_INLINE void operator delete(void* p, ZoneAllocationPolicy allocator) {
+    UNREACHABLE();
+  }
+
+  void* operator new(size_t size, Zone* zone) { return zone->New(size); }
+
+  // Returns a reference to the element at index i. This reference is not safe
+  // to use after operations that can change the list's backing store
+  // (e.g. Add).
+  inline T& operator[](int i) const {
+    DCHECK_LE(0, i);
+    DCHECK_GT(static_cast<unsigned>(length_), static_cast<unsigned>(i));
+    return data_[i];
+  }
+  inline T& at(int i) const { return operator[](i); }
+  inline T& last() const { return at(length_ - 1); }
+  inline T& first() const { return at(0); }
+
+  using iterator = T*;
+  inline iterator begin() const { return &data_[0]; }
+  inline iterator end() const { return &data_[length_]; }
+
+  V8_INLINE bool is_empty() const { return length_ == 0; }
+  V8_INLINE int length() const { return length_; }
+  V8_INLINE int capacity() const { return capacity_; }
+
+  Vector<T> ToVector() const { return Vector<T>(data_, length_); }
+  Vector<T> ToVector(int start, int length) const {
+    return Vector<T>(data_ + start, std::min(length_ - start, length));
+  }
+
+  Vector<const T> ToConstVector() const {
+    return Vector<const T>(data_, length_);
+  }
+
+  V8_INLINE void Initialize(int capacity, Zone* zone) {
+    DCHECK_GE(capacity, 0);
+    data_ = (capacity > 0) ? NewData(capacity, ZoneAllocationPolicy(zone))
+                           : nullptr;
+    capacity_ = capacity;
+    length_ = 0;
+  }
+
+  // Adds a copy of the given 'element' to the end of the list,
+  // expanding the list if necessary.
+  void Add(const T& element, Zone* zone);
+  // Add all the elements from the argument list to this list.
+  void AddAll(const ZoneList<T>& other, Zone* zone);
+  // Add all the elements from the vector to this list.
+  void AddAll(const Vector<T>& other, Zone* zone);
+  // Inserts the element at the specific index.
+  void InsertAt(int index, const T& element, Zone* zone);
+
+  // Added 'count' elements with the value 'value' and returns a
+  // vector that allows access to the elements. The vector is valid
+  // until the next change is made to this list.
+  Vector<T> AddBlock(T value, int count, Zone* zone);
+
+  // Overwrites the element at the specific index.
+  void Set(int index, const T& element);
+
+  // Removes the i'th element without deleting it even if T is a
+  // pointer type; moves all elements above i "down". Returns the
+  // removed element.  This function's complexity is linear in the
+  // size of the list.
+  T Remove(int i);
+
+  // Removes the last element without deleting it even if T is a
+  // pointer type. Returns the removed element.
+  V8_INLINE T RemoveLast() { return Remove(length_ - 1); }
+
+  // Clears the list by freeing the storage memory. If you want to keep the
+  // memory, use Rewind(0) instead. Be aware, that even if T is a
+  // pointer type, clearing the list doesn't delete the entries.
+  V8_INLINE void Clear();
+
+  // Drops all but the first 'pos' elements from the list.
+  V8_INLINE void Rewind(int pos);
+
+  inline bool Contains(const T& elm) const {
+    for (int i = 0; i < length_; i++) {
+      if (data_[i] == elm) return true;
+    }
+    return false;
+  }
+
+  // Iterate through all list entries, starting at index 0.
+  template <class Visitor>
+  void Iterate(Visitor* visitor);
+
+  // Sort all list entries (using QuickSort)
+  template <typename CompareFunction>
+  void Sort(CompareFunction cmp);
+  template <typename CompareFunction>
+  void StableSort(CompareFunction cmp, size_t start, size_t length);
+
+  void operator delete(void* pointer) { UNREACHABLE(); }
+  void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
+
+ private:
+  T* data_;
+  int capacity_;
+  int length_;
+
+  V8_INLINE T* NewData(int n, ZoneAllocationPolicy allocator) {
+    return static_cast<T*>(allocator.New(n * sizeof(T)));
+  }
+  V8_INLINE void DeleteData(T* data) { ZoneAllocationPolicy::Delete(data); }
+
+  // Increase the capacity of a full list, and add an element.
+  // List must be full already.
+  void ResizeAdd(const T& element, ZoneAllocationPolicy allocator);
+
+  // Inlined implementation of ResizeAdd, shared by inlined and
+  // non-inlined versions of ResizeAdd.
+  void ResizeAddInternal(const T& element, ZoneAllocationPolicy allocator);
+
+  // Resize the list.
+  void Resize(int new_capacity, ZoneAllocationPolicy allocator);
+
+  DISALLOW_COPY_AND_ASSIGN(ZoneList);
+};
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_ZONE_ZONE_LIST_H_

src/zone/zone.h

@@ -5,11 +5,8 @@
 #ifndef V8_ZONE_ZONE_H_
 #define V8_ZONE_ZONE_H_
 
-#include <algorithm>
 #include <limits>
-#include <vector>
 
-#include "src/base/hashmap.h"
 #include "src/base/logging.h"
 #include "src/common/globals.h"
 #include "src/zone/accounting-allocator.h"
@@ -171,263 +168,6 @@ class ZoneAllocationPolicy final {
   Zone* zone_;
 };
 
-template <typename T>
-class Vector;
-
-// ZoneLists are growable lists with constant-time access to the
-// elements. The list itself and all its elements are allocated in the
-// Zone. ZoneLists cannot be deleted individually; you can delete all
-// objects in the Zone by calling Zone::DeleteAll().
-template <typename T>
-class ZoneList final {
- public:
-  // Construct a new ZoneList with the given capacity; the length is
-  // always zero. The capacity must be non-negative.
-  ZoneList(int capacity, Zone* zone) { Initialize(capacity, zone); }
-  // Construct a new ZoneList from a std::initializer_list
-  ZoneList(std::initializer_list<T> list, Zone* zone) {
-    Initialize(static_cast<int>(list.size()), zone);
-    for (auto& i : list) Add(i, zone);
-  }
-  // Construct a new ZoneList by copying the elements of the given ZoneList.
-  ZoneList(const ZoneList<T>& other, Zone* zone) {
-    Initialize(other.length(), zone);
-    AddAll(other, zone);
-  }
-
-  V8_INLINE ~ZoneList() { DeleteData(data_); }
-
-  // Please the MSVC compiler.  We should never have to execute this.
-  V8_INLINE void operator delete(void* p, ZoneAllocationPolicy allocator) {
-    UNREACHABLE();
-  }
-
-  void* operator new(size_t size, Zone* zone) { return zone->New(size); }
-
-  // Returns a reference to the element at index i. This reference is not safe
-  // to use after operations that can change the list's backing store
-  // (e.g. Add).
-  inline T& operator[](int i) const {
-    DCHECK_LE(0, i);
-    DCHECK_GT(static_cast<unsigned>(length_), static_cast<unsigned>(i));
-    return data_[i];
-  }
-  inline T& at(int i) const { return operator[](i); }
-  inline T& last() const { return at(length_ - 1); }
-  inline T& first() const { return at(0); }
-
-  using iterator = T*;
-  inline iterator begin() const { return &data_[0]; }
-  inline iterator end() const { return &data_[length_]; }
-
-  V8_INLINE bool is_empty() const { return length_ == 0; }
-  V8_INLINE int length() const { return length_; }
-  V8_INLINE int capacity() const { return capacity_; }
-
-  Vector<T> ToVector() const { return Vector<T>(data_, length_); }
-  Vector<T> ToVector(int start, int length) const {
-    return Vector<T>(data_ + start, std::min(length_ - start, length));
-  }
-
-  Vector<const T> ToConstVector() const {
-    return Vector<const T>(data_, length_);
-  }
-
-  V8_INLINE void Initialize(int capacity, Zone* zone) {
-    DCHECK_GE(capacity, 0);
-    data_ = (capacity > 0) ? NewData(capacity, ZoneAllocationPolicy(zone))
-                           : nullptr;
-    capacity_ = capacity;
-    length_ = 0;
-  }
-
-  // Adds a copy of the given 'element' to the end of the list,
-  // expanding the list if necessary.
-  void Add(const T& element, Zone* zone);
-  // Add all the elements from the argument list to this list.
-  void AddAll(const ZoneList<T>& other, Zone* zone);
-  // Add all the elements from the vector to this list.
-  void AddAll(const Vector<T>& other, Zone* zone);
-  // Inserts the element at the specific index.
-  void InsertAt(int index, const T& element, Zone* zone);
-
-  // Added 'count' elements with the value 'value' and returns a
-  // vector that allows access to the elements. The vector is valid
-  // until the next change is made to this list.
-  Vector<T> AddBlock(T value, int count, Zone* zone);
-
-  // Overwrites the element at the specific index.
-  void Set(int index, const T& element);
-
-  // Removes the i'th element without deleting it even if T is a
-  // pointer type; moves all elements above i "down". Returns the
-  // removed element.  This function's complexity is linear in the
-  // size of the list.
-  T Remove(int i);
-
-  // Removes the last element without deleting it even if T is a
-  // pointer type. Returns the removed element.
-  V8_INLINE T RemoveLast() { return Remove(length_ - 1); }
-
-  // Clears the list by freeing the storage memory. If you want to keep the
-  // memory, use Rewind(0) instead. Be aware, that even if T is a
-  // pointer type, clearing the list doesn't delete the entries.
-  V8_INLINE void Clear();
-
-  // Drops all but the first 'pos' elements from the list.
-  V8_INLINE void Rewind(int pos);
-
-  inline bool Contains(const T& elm) const {
-    for (int i = 0; i < length_; i++) {
-      if (data_[i] == elm) return true;
-    }
-    return false;
-  }
-
-  // Iterate through all list entries, starting at index 0.
-  template <class Visitor>
-  void Iterate(Visitor* visitor);
-
-  // Sort all list entries (using QuickSort)
-  template <typename CompareFunction>
-  void Sort(CompareFunction cmp);
-  template <typename CompareFunction>
-  void StableSort(CompareFunction cmp, size_t start, size_t length);
-
-  void operator delete(void* pointer) { UNREACHABLE(); }
-  void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
-
- private:
-  T* data_;
-  int capacity_;
-  int length_;
-
-  V8_INLINE T* NewData(int n, ZoneAllocationPolicy allocator) {
-    return static_cast<T*>(allocator.New(n * sizeof(T)));
-  }
-  V8_INLINE void DeleteData(T* data) { ZoneAllocationPolicy::Delete(data); }
-
-  // Increase the capacity of a full list, and add an element.
-  // List must be full already.
-  void ResizeAdd(const T& element, ZoneAllocationPolicy allocator);
-
-  // Inlined implementation of ResizeAdd, shared by inlined and
-  // non-inlined versions of ResizeAdd.
-  void ResizeAddInternal(const T& element, ZoneAllocationPolicy allocator);
-
-  // Resize the list.
-  void Resize(int new_capacity, ZoneAllocationPolicy allocator);
-
-  DISALLOW_COPY_AND_ASSIGN(ZoneList);
-};
-
-// ZonePtrList is a ZoneList of pointers to ZoneObjects allocated in the same
-// zone as the list object.
-template <typename T>
-using ZonePtrList = ZoneList<T*>;
-
-// ScopedList is a scope-lifetime list with a std::vector backing that can be
-// re-used between ScopedLists. Note that a ScopedList in an outer scope cannot
-// add any entries if there is a ScopedList with the same backing in an inner
-// scope.
-template <typename T, typename TBacking = T>
-class ScopedList final {
-  // The backing can either be the same type as the list type, or, for pointers,
-  // we additionally allow a void* backing store.
-  STATIC_ASSERT((std::is_same<TBacking, T>::value) ||
-                (std::is_same<TBacking, void*>::value &&
-                 std::is_pointer<T>::value));
-
- public:
-  explicit ScopedList(std::vector<TBacking>* buffer)
-      : buffer_(*buffer), start_(buffer->size()), end_(buffer->size()) {}
-
-  ~ScopedList() { Rewind(); }
-
-  void Rewind() {
-    DCHECK_EQ(buffer_.size(), end_);
-    buffer_.resize(start_);
-    end_ = start_;
-  }
-
-  void MergeInto(ScopedList* parent) {
-    DCHECK_EQ(parent->end_, start_);
-    parent->end_ = end_;
-    start_ = end_;
-    DCHECK_EQ(0, length());
-  }
-
-  int length() const { return static_cast<int>(end_ - start_); }
-
-  const T& at(int i) const {
-    size_t index = start_ + i;
-    DCHECK_LE(start_, index);
-    DCHECK_LT(index, buffer_.size());
-    return *reinterpret_cast<T*>(&buffer_[index]);
-  }
-
-  T& at(int i) {
-    size_t index = start_ + i;
-    DCHECK_LE(start_, index);
-    DCHECK_LT(index, buffer_.size());
-    return *reinterpret_cast<T*>(&buffer_[index]);
-  }
-
-  void CopyTo(ZoneList<T>* target, Zone* zone) const {
-    DCHECK_LE(end_, buffer_.size());
-    // Make sure we don't reference absent elements below.
-    if (length() == 0) return;
-    target->Initialize(length(), zone);
-    T* data = reinterpret_cast<T*>(&buffer_[start_]);
-    target->AddAll(Vector<T>(data, length()), zone);
-  }
-
-  Vector<T> CopyTo(Zone* zone) {
-    DCHECK_LE(end_, buffer_.size());
-    T* data = zone->NewArray<T>(length());
-    if (length() != 0) {
-      MemCopy(data, &buffer_[start_], length() * sizeof(T));
-    }
-    return Vector<T>(data, length());
-  }
-
-  void Add(const T& value) {
-    DCHECK_EQ(buffer_.size(), end_);
-    buffer_.push_back(value);
-    ++end_;
-  }
-
-  void AddAll(const ZoneList<T>& list) {
-    DCHECK_EQ(buffer_.size(), end_);
-    buffer_.reserve(buffer_.size() + list.length());
-    for (int i = 0; i < list.length(); i++) {
-      buffer_.push_back(list.at(i));
-    }
-    end_ += list.length();
-  }
-
-  using iterator = T*;
-  inline iterator begin() const {
-    return reinterpret_cast<T*>(buffer_.data() + start_);
-  }
-  inline iterator end() const {
-    return reinterpret_cast<T*>(buffer_.data() + end_);
-  }
-
- private:
-  std::vector<TBacking>& buffer_;
-  size_t start_;
-  size_t end_;
-};
-
-template <typename T>
-using ScopedPtrList = ScopedList<T*, void*>;
-
-using ZoneHashMap = base::PointerTemplateHashMapImpl<ZoneAllocationPolicy>;
-
-using CustomMatcherZoneHashMap =
-    base::CustomMatcherTemplateHashMapImpl<ZoneAllocationPolicy>;
-
 }  // namespace internal
 }  // namespace v8