File Explorer

1// Copyright 2021 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4 5#ifndef INCLUDE_V8_LOCAL_HANDLE_H_6#define INCLUDE_V8_LOCAL_HANDLE_H_7 8#include <stddef.h>9 10#include <type_traits>11#include <vector>12 13#include "v8-handle-base.h"  // NOLINT(build/include_directory)14#include "v8-internal.h"     // NOLINT(build/include_directory)15 16namespace v8 {17 18template <class T>19class LocalBase;20template <class T>21class Local;22template <class T>23class LocalVector;24template <class F>25class MaybeLocal;26 27template <class T>28class Eternal;29template <class T>30class Global;31 32template <class T>33class NonCopyablePersistentTraits;34template <class T>35class PersistentBase;36template <class T, class M = NonCopyablePersistentTraits<T>>37class Persistent;38 39class TracedReferenceBase;40template <class T>41class BasicTracedReference;42template <class F>43class TracedReference;44 45class Boolean;46class Context;47class EscapableHandleScope;48template <class F>49class FunctionCallbackInfo;50class Isolate;51class Object;52template <class F1, class F2, class F3>53class PersistentValueMapBase;54class Primitive;55class Private;56template <class F>57class PropertyCallbackInfo;58template <class F>59class ReturnValue;60class String;61template <class F>62class Traced;63class TypecheckWitness;64class Utils;65 66namespace debug {67class ConsoleCallArguments;68}69 70namespace internal {71template <typename T>72class CustomArguments;73template <typename T>74class LocalUnchecked;75class SamplingHeapProfiler;76}  // namespace internal77 78namespace api_internal {79// Called when ToLocalChecked is called on an empty Local.80V8_EXPORT void ToLocalEmpty();81}  // namespace api_internal82 83/**84 * A stack-allocated class that governs a number of local handles.85 * After a handle scope has been created, all local handles will be86 * allocated within that handle scope until either the handle scope is87 * deleted or another handle scope is created.  If there is already a88 * handle scope and a new one is created, all allocations will take89 * place in the new handle scope until it is deleted.  After that,90 * new handles will again be allocated in the original handle scope.91 *92 * After the handle scope of a local handle has been deleted the93 * garbage collector will no longer track the object stored in the94 * handle and may deallocate it.  The behavior of accessing a handle95 * for which the handle scope has been deleted is undefined.96 */97class V8_EXPORT V8_NODISCARD HandleScope {98 public:99  explicit HandleScope(Isolate* isolate);100 101  ~HandleScope();102 103  /**104   * Counts the number of allocated handles.105   */106  static int NumberOfHandles(Isolate* isolate);107 108  V8_INLINE Isolate* GetIsolate() const {109    return reinterpret_cast<Isolate*>(i_isolate_);110  }111 112  HandleScope(const HandleScope&) = delete;113  void operator=(const HandleScope&) = delete;114 115  static internal::Address* CreateHandleForCurrentIsolate(116      internal::Address value);117 118 protected:119  V8_INLINE HandleScope() = default;120 121  void Initialize(Isolate* isolate);122 123  static internal::Address* CreateHandle(internal::Isolate* i_isolate,124                                         internal::Address value);125 126 private:127  // Declaring operator new and delete as deleted is not spec compliant.128  // Therefore declare them private instead to disable dynamic alloc129  void* operator new(size_t size);130  void* operator new[](size_t size);131  void operator delete(void*, size_t);132  void operator delete[](void*, size_t);133 134  internal::Isolate* i_isolate_;135  internal::Address* prev_next_;136  internal::Address* prev_limit_;137#ifdef V8_ENABLE_CHECKS138  int scope_level_ = 0;139#endif140 141  // LocalBase<T>::New uses CreateHandle with an Isolate* parameter.142  template <typename T>143  friend class LocalBase;144 145  // Object::GetInternalField and Context::GetEmbedderData use CreateHandle with146  // a HeapObject in their shortcuts.147  friend class Object;148  friend class Context;149};150 151/**152 * A base class for local handles.153 * Its implementation depends on whether direct handle support is enabled.154 * When it is, a local handle contains a direct pointer to the referenced155 * object, otherwise it contains an indirect pointer.156 */157#ifdef V8_ENABLE_DIRECT_HANDLE158 159template <typename T>160class LocalBase : public api_internal::DirectHandleBase {161 protected:162  template <class F>163  friend class Local;164 165  V8_INLINE LocalBase() = default;166 167  V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {}168 169  template <typename S>170  V8_INLINE LocalBase(const LocalBase<S>& other) : DirectHandleBase(other) {}171 172  V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) {173    return LocalBase<T>(value);174  }175 176  V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) {177    return LocalBase<T>::New(isolate,178                             internal::ValueHelper::ValueAsAddress(that));179  }180 181  V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {182    if (slot == nullptr) return LocalBase<T>();183    return LocalBase<T>(*slot);184  }185 186  V8_INLINE static LocalBase<T> FromRepr(187      internal::ValueHelper::InternalRepresentationType repr) {188    return LocalBase<T>(repr);189  }190};191 192#else  // !V8_ENABLE_DIRECT_HANDLE193 194template <typename T>195class LocalBase : public api_internal::IndirectHandleBase {196 protected:197  template <class F>198  friend class Local;199 200  V8_INLINE LocalBase() = default;201 202  V8_INLINE explicit LocalBase(internal::Address* location)203      : IndirectHandleBase(location) {}204 205  template <typename S>206  V8_INLINE LocalBase(const LocalBase<S>& other) : IndirectHandleBase(other) {}207 208  V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) {209    return LocalBase(HandleScope::CreateHandle(210        reinterpret_cast<internal::Isolate*>(isolate), value));211  }212 213  V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) {214    if (internal::ValueHelper::IsEmpty(that)) return LocalBase<T>();215    return LocalBase<T>::New(isolate,216                             internal::ValueHelper::ValueAsAddress(that));217  }218 219  V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {220    return LocalBase<T>(slot);221  }222 223  V8_INLINE static LocalBase<T> FromRepr(224      internal::ValueHelper::InternalRepresentationType repr) {225    return LocalBase<T>(repr);226  }227};228 229#endif  // V8_ENABLE_DIRECT_HANDLE230 231/**232 * An object reference managed by the v8 garbage collector.233 *234 * All objects returned from v8 have to be tracked by the garbage collector so235 * that it knows that the objects are still alive.  Also, because the garbage236 * collector may move objects, it is unsafe to point directly to an object.237 * Instead, all objects are stored in handles which are known by the garbage238 * collector and updated whenever an object moves.  Handles should always be239 * passed by value (except in cases like out-parameters) and they should never240 * be allocated on the heap.241 *242 * There are two types of handles: local and persistent handles.243 *244 * Local handles are light-weight and transient and typically used in local245 * operations.  They are managed by HandleScopes. That means that a HandleScope246 * must exist on the stack when they are created and that they are only valid247 * inside of the HandleScope active during their creation. For passing a local248 * handle to an outer HandleScope, an EscapableHandleScope and its Escape()249 * method must be used.250 *251 * Persistent handles can be used when storing objects across several252 * independent operations and have to be explicitly deallocated when they're no253 * longer used.254 *255 * It is safe to extract the object stored in the handle by dereferencing the256 * handle (for instance, to extract the Object* from a Local<Object>); the value257 * will still be governed by a handle behind the scenes and the same rules apply258 * to these values as to their handles.259 */260template <class T>261class V8_TRIVIAL_ABI Local : public LocalBase<T>,262#ifdef V8_ENABLE_LOCAL_OFF_STACK_CHECK263                             public api_internal::StackAllocated<true>264#else265                             public api_internal::StackAllocated<false>266#endif267{268 public:269  /**270   * Default constructor: Returns an empty handle.271   */272  V8_INLINE Local() = default;273 274  /**275   * Constructor for handling automatic up casting.276   * Ex. Local<Object> can be passed when Local<Value> is expected but not277   * the other way round.278   */279  template <class S>280    requires std::is_base_of_v<T, S>281  V8_INLINE Local(Local<S> that) : LocalBase<T>(that) {}282 283  V8_INLINE T* operator->() const { return this->template value<T>(); }284 285  V8_INLINE T* operator*() const { return this->operator->(); }286 287  /**288   * Checks whether two handles are equal or different.289   * They are equal iff they are both empty or they are both non-empty and the290   * objects to which they refer are physically equal.291   *292   * If both handles refer to JS objects, this is the same as strict293   * non-equality. For primitives, such as numbers or strings, a `true` return294   * value does not indicate that the values aren't equal in the JavaScript295   * sense. Use `Value::StrictEquals()` to check primitives for equality.296   */297 298  template <class S>299  V8_INLINE bool operator==(const Local<S>& that) const {300    return internal::HandleHelper::EqualHandles(*this, that);301  }302 303  template <class S>304  V8_INLINE bool operator==(const PersistentBase<S>& that) const {305    return internal::HandleHelper::EqualHandles(*this, that);306  }307 308  template <class S>309  V8_INLINE bool operator!=(const Local<S>& that) const {310    return !operator==(that);311  }312 313  template <class S>314  V8_INLINE bool operator!=(const Persistent<S>& that) const {315    return !operator==(that);316  }317 318  /**319   * Cast a handle to a subclass, e.g. Local<Value> to Local<Object>.320   * This is only valid if the handle actually refers to a value of the321   * target type or if the handle is empty.322   */323  template <class S>324  V8_INLINE static Local<T> Cast(Local<S> that) {325#ifdef V8_ENABLE_CHECKS326    // If we're going to perform the type check then we have to check327    // that the handle isn't empty before doing the checked cast.328    if (that.IsEmpty()) return Local<T>();329    T::Cast(that.template value<S>());330#endif331    return Local<T>(LocalBase<T>(that));332  }333 334  /**335   * Calling this is equivalent to Local<S>::Cast().336   * In particular, this is only valid if the handle actually refers to a value337   * of the target type or if the handle is empty.338   */339  template <class S>340  V8_INLINE Local<S> As() const {341    return Local<S>::Cast(*this);342  }343 344  /**345   * Create a local handle for the content of another handle.346   * The referee is kept alive by the local handle even when347   * the original handle is destroyed/disposed.348   */349  V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that) {350    return New(isolate, that.template value<T, true>());351  }352 353  V8_INLINE static Local<T> New(Isolate* isolate,354                                const PersistentBase<T>& that) {355    return New(isolate, that.template value<T, true>());356  }357 358  V8_INLINE static Local<T> New(Isolate* isolate,359                                const BasicTracedReference<T>& that) {360    return New(isolate, that.template value<T, true>());361  }362 363 private:364  friend class TracedReferenceBase;365  friend class Utils;366  template <class F>367  friend class Eternal;368  template <class F>369  friend class Global;370  template <class F>371  friend class Local;372  template <class F>373  friend class MaybeLocal;374  template <class F, class M>375  friend class Persistent;376  template <class F>377  friend class FunctionCallbackInfo;378  template <class F>379  friend class PropertyCallbackInfo;380  friend class String;381  friend class Object;382  friend class Context;383  friend class Isolate;384  friend class Private;385  template <class F>386  friend class internal::CustomArguments;387  friend Local<Primitive> Undefined(Isolate* isolate);388  friend Local<Primitive> Null(Isolate* isolate);389  friend Local<Boolean> True(Isolate* isolate);390  friend Local<Boolean> False(Isolate* isolate);391  friend class HandleScope;392  friend class EscapableHandleScope;393  friend class InternalEscapableScope;394  template <class F1, class F2, class F3>395  friend class PersistentValueMapBase;396  template <class F>397  friend class ReturnValue;398  template <class F>399  friend class Traced;400  friend class internal::SamplingHeapProfiler;401  friend class internal::HandleHelper;402  friend class debug::ConsoleCallArguments;403  friend class internal::LocalUnchecked<T>;404 405  explicit Local(no_checking_tag do_not_check)406      : LocalBase<T>(), StackAllocated(do_not_check) {}407  explicit Local(const Local<T>& other, no_checking_tag do_not_check)408      : LocalBase<T>(other), StackAllocated(do_not_check) {}409 410  V8_INLINE explicit Local(const LocalBase<T>& other) : LocalBase<T>(other) {}411 412  V8_INLINE static Local<T> FromRepr(413      internal::ValueHelper::InternalRepresentationType repr) {414    return Local<T>(LocalBase<T>::FromRepr(repr));415  }416 417  V8_INLINE static Local<T> FromSlot(internal::Address* slot) {418    return Local<T>(LocalBase<T>::FromSlot(slot));419  }420 421#ifdef V8_ENABLE_DIRECT_HANDLE422  friend class TypecheckWitness;423 424  V8_INLINE static Local<T> FromAddress(internal::Address ptr) {425    return Local<T>(LocalBase<T>(ptr));426  }427#endif  // V8_ENABLE_DIRECT_HANDLE428 429  V8_INLINE static Local<T> New(Isolate* isolate, internal::Address value) {430    return Local<T>(LocalBase<T>::New(isolate, value));431  }432 433  V8_INLINE static Local<T> New(Isolate* isolate, T* that) {434    return Local<T>(LocalBase<T>::New(isolate, that));435  }436 437  // Unsafe cast, should be avoided.438  template <class S>439  V8_INLINE Local<S> UnsafeAs() const {440    return Local<S>(LocalBase<S>(*this));441  }442};443 444namespace internal {445// A local variant that is suitable for off-stack allocation.446// Used internally by LocalVector<T>. Not to be used directly!447template <typename T>448class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> {449 public:450  LocalUnchecked() : Local<T>(Local<T>::do_not_check) {}451 452#if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI453  // In this case, the check is also enforced in the copy constructor and we454  // need to suppress it.455  LocalUnchecked(456      const LocalUnchecked& other) noexcept  // NOLINT(runtime/explicit)457      : Local<T>(other, Local<T>::do_not_check) {}458  LocalUnchecked& operator=(const LocalUnchecked&) noexcept = default;459#endif460 461  // Implicit conversion from Local.462  LocalUnchecked(const Local<T>& other) noexcept  // NOLINT(runtime/explicit)463      : Local<T>(other, Local<T>::do_not_check) {}464};465 466#ifdef V8_ENABLE_DIRECT_HANDLE467// Off-stack allocated direct locals must be registered as strong roots.468// For off-stack indirect locals, this is not necessary.469 470template <typename T>471class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {472 public:473  using value_type = LocalUnchecked<T>;474  static_assert(std::is_standard_layout_v<value_type>);475  static_assert(sizeof(value_type) == sizeof(Address));476 477  template <typename HeapOrIsolateT>478  explicit StrongRootAllocator(HeapOrIsolateT* heap_or_isolate)479      : StrongRootAllocatorBase(heap_or_isolate) {}480  template <typename U>481  StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept482      : StrongRootAllocatorBase(other) {}483 484  value_type* allocate(size_t n) {485    return reinterpret_cast<value_type*>(allocate_impl(n));486  }487  void deallocate(value_type* p, size_t n) noexcept {488    return deallocate_impl(reinterpret_cast<Address*>(p), n);489  }490};491#endif  // V8_ENABLE_DIRECT_HANDLE492}  // namespace internal493 494template <typename T>495class LocalVector {496 private:497  using element_type = internal::LocalUnchecked<T>;498 499#ifdef V8_ENABLE_DIRECT_HANDLE500  using allocator_type = internal::StrongRootAllocator<element_type>;501 502  static allocator_type make_allocator(Isolate* isolate) noexcept {503    return allocator_type(isolate);504  }505#else506  using allocator_type = std::allocator<element_type>;507 508  static allocator_type make_allocator(Isolate* isolate) noexcept {509    return allocator_type();510  }511#endif  // V8_ENABLE_DIRECT_HANDLE512 513  using vector_type = std::vector<element_type, allocator_type>;514 515 public:516  using value_type = Local<T>;517  using reference = value_type&;518  using const_reference = const value_type&;519  using size_type = size_t;520  using difference_type = ptrdiff_t;521  using iterator =522      internal::WrappedIterator<typename vector_type::iterator, Local<T>>;523  using const_iterator =524      internal::WrappedIterator<typename vector_type::const_iterator,525                                const Local<T>>;526 527  explicit LocalVector(Isolate* isolate) : backing_(make_allocator(isolate)) {}528  LocalVector(Isolate* isolate, size_t n)529      : backing_(n, make_allocator(isolate)) {}530  explicit LocalVector(Isolate* isolate, std::initializer_list<Local<T>> init)531      : backing_(make_allocator(isolate)) {532    if (init.size() == 0) return;533    backing_.reserve(init.size());534    backing_.insert(backing_.end(), init.begin(), init.end());535  }536 537  iterator begin() noexcept { return iterator(backing_.begin()); }538  const_iterator begin() const noexcept {539    return const_iterator(backing_.begin());540  }541  iterator end() noexcept { return iterator(backing_.end()); }542  const_iterator end() const noexcept { return const_iterator(backing_.end()); }543 544  size_t size() const noexcept { return backing_.size(); }545  bool empty() const noexcept { return backing_.empty(); }546  void reserve(size_t n) { backing_.reserve(n); }547  void shrink_to_fit() { backing_.shrink_to_fit(); }548 549  Local<T>& operator[](size_t n) { return backing_[n]; }550  const Local<T>& operator[](size_t n) const { return backing_[n]; }551 552  Local<T>& at(size_t n) { return backing_.at(n); }553  const Local<T>& at(size_t n) const { return backing_.at(n); }554 555  Local<T>& front() { return backing_.front(); }556  const Local<T>& front() const { return backing_.front(); }557  Local<T>& back() { return backing_.back(); }558  const Local<T>& back() const { return backing_.back(); }559 560  Local<T>* data() noexcept { return backing_.data(); }561  const Local<T>* data() const noexcept { return backing_.data(); }562 563  iterator insert(const_iterator pos, const Local<T>& value) {564    return iterator(backing_.insert(pos.base(), value));565  }566 567  template <typename InputIt>568  iterator insert(const_iterator pos, InputIt first, InputIt last) {569    return iterator(backing_.insert(pos.base(), first, last));570  }571 572  iterator insert(const_iterator pos, std::initializer_list<Local<T>> init) {573    return iterator(backing_.insert(pos.base(), init.begin(), init.end()));574  }575 576  LocalVector<T>& operator=(std::initializer_list<Local<T>> init) {577    backing_.clear();578    backing_.reserve(init.size());579    backing_.insert(backing_.end(), init.begin(), init.end());580    return *this;581  }582 583  void push_back(const Local<T>& x) { backing_.push_back(x); }584  void pop_back() { backing_.pop_back(); }585 586  template <typename... Args>587  void emplace_back(Args&&... args) {588    backing_.push_back(value_type{std::forward<Args>(args)...});589  }590 591  void clear() noexcept { backing_.clear(); }592  void resize(size_t n) { backing_.resize(n); }593  void swap(LocalVector<T>& other) { backing_.swap(other.backing_); }594 595  friend bool operator==(const LocalVector<T>& x, const LocalVector<T>& y) {596    return x.backing_ == y.backing_;597  }598  friend bool operator!=(const LocalVector<T>& x, const LocalVector<T>& y) {599    return x.backing_ != y.backing_;600  }601  friend bool operator<(const LocalVector<T>& x, const LocalVector<T>& y) {602    return x.backing_ < y.backing_;603  }604  friend bool operator>(const LocalVector<T>& x, const LocalVector<T>& y) {605    return x.backing_ > y.backing_;606  }607  friend bool operator<=(const LocalVector<T>& x, const LocalVector<T>& y) {608    return x.backing_ <= y.backing_;609  }610  friend bool operator>=(const LocalVector<T>& x, const LocalVector<T>& y) {611    return x.backing_ >= y.backing_;612  }613 614 private:615  vector_type backing_;616};617 618#if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)619// Handle is an alias for Local for historical reasons.620template <class T>621using Handle = Local<T>;622#endif623 624/**625 * A MaybeLocal<> is a wrapper around Local<> that enforces a check whether626 * the Local<> is empty before it can be used.627 *628 * If an API method returns a MaybeLocal<>, the API method can potentially fail629 * either because an exception is thrown, or because an exception is pending,630 * e.g. because a previous API call threw an exception that hasn't been caught631 * yet, or because a TerminateExecution exception was thrown. In that case, an632 * empty MaybeLocal is returned.633 */634template <class T>635class MaybeLocal {636 public:637  /**638   * Default constructor: Returns an empty handle.639   */640  V8_INLINE MaybeLocal() = default;641  /**642   * Implicitly construct MaybeLocal from Local.643   */644  template <class S>645    requires std::is_base_of_v<T, S>646  V8_INLINE MaybeLocal(Local<S> that) : local_(that) {}647  /**648   * Implicitly up-cast MaybeLocal<S> to MaybeLocal<T> if T is a base of S.649   */650  template <class S>651    requires std::is_base_of_v<T, S>652  V8_INLINE MaybeLocal(MaybeLocal<S> that) : local_(that.local_) {}653 654  V8_INLINE bool IsEmpty() const { return local_.IsEmpty(); }655 656  /**657   * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty,658   * |false| is returned and |out| is assigned with nullptr.659   */660  template <class S>661  V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const {662    *out = local_;663    return !IsEmpty();664  }665 666  /**667   * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty,668   * V8 will crash the process.669   */670  V8_INLINE Local<T> ToLocalChecked() {671    if (V8_UNLIKELY(IsEmpty())) api_internal::ToLocalEmpty();672    return local_;673  }674 675  /**676   * Converts this MaybeLocal<> to a Local<>, using a default value if this677   * MaybeLocal<> is empty.678   */679  template <class S>680  V8_INLINE Local<S> FromMaybe(Local<S> default_value) const {681    return IsEmpty() ? default_value : Local<S>(local_);682  }683 684  /**685   * Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>.686   * This is only valid if the handle actually refers to a value of the target687   * type or if the handle is empty.688   */689  template <class S>690  V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) {691    return MaybeLocal<T>{Local<T>::Cast(that.local_)};692  }693 694  /**695   * Calling this is equivalent to MaybeLocal<S>::Cast().696   * In particular, this is only valid if the handle actually refers to a value697   * of the target type or if the handle is empty.698   */699  template <class S>700  V8_INLINE MaybeLocal<S> As() const {701    return MaybeLocal<S>::Cast(*this);702  }703 704 private:705  Local<T> local_;706 707  template <typename S>708  friend class MaybeLocal;709};710 711/**712 * A HandleScope which first allocates a handle in the current scope713 * which will be later filled with the escape value.714 */715class V8_EXPORT V8_NODISCARD EscapableHandleScopeBase : public HandleScope {716 public:717  explicit EscapableHandleScopeBase(Isolate* isolate);718  V8_INLINE ~EscapableHandleScopeBase() = default;719 720  EscapableHandleScopeBase(const EscapableHandleScopeBase&) = delete;721  void operator=(const EscapableHandleScopeBase&) = delete;722  void* operator new(size_t size) = delete;723  void* operator new[](size_t size) = delete;724  void operator delete(void*, size_t) = delete;725  void operator delete[](void*, size_t) = delete;726 727 protected:728  /**729   * Pushes the value into the previous scope and returns a handle to it.730   * Cannot be called twice.731   */732  internal::Address* EscapeSlot(internal::Address* escape_value);733 734 private:735  internal::Address* escape_slot_;736};737 738class V8_EXPORT V8_NODISCARD EscapableHandleScope739    : public EscapableHandleScopeBase {740 public:741  explicit EscapableHandleScope(Isolate* isolate)742      : EscapableHandleScopeBase(isolate) {}743  V8_INLINE ~EscapableHandleScope() = default;744  template <class T>745  V8_INLINE Local<T> Escape(Local<T> value) {746#ifdef V8_ENABLE_DIRECT_HANDLE747    return value;748#else749    if (value.IsEmpty()) return value;750    return Local<T>::FromSlot(EscapeSlot(value.slot()));751#endif752  }753 754  template <class T>755  V8_INLINE MaybeLocal<T> EscapeMaybe(MaybeLocal<T> value) {756    return Escape(value.FromMaybe(Local<T>()));757  }758};759 760/**761 * A SealHandleScope acts like a handle scope in which no handle allocations762 * are allowed. It can be useful for debugging handle leaks.763 * Handles can be allocated within inner normal HandleScopes.764 */765class V8_EXPORT V8_NODISCARD SealHandleScope {766 public:767  explicit SealHandleScope(Isolate* isolate);768  ~SealHandleScope();769 770  SealHandleScope(const SealHandleScope&) = delete;771  void operator=(const SealHandleScope&) = delete;772  void* operator new(size_t size) = delete;773  void* operator new[](size_t size) = delete;774  void operator delete(void*, size_t) = delete;775  void operator delete[](void*, size_t) = delete;776 777 private:778  internal::Isolate* const i_isolate_;779  internal::Address* prev_limit_;780  int prev_sealed_level_;781};782 783}  // namespace v8784 785#endif  // INCLUDE_V8_LOCAL_HANDLE_H_786