libv8-node 17.9.1.0-x86_64-linux-musl → 18.13.0.0-x86_64-linux-musl

data/vendor/v8/include/v8-script.h

@@ -47,7 +47,9 @@ class V8_EXPORT ScriptOrModule {
    * The options that were passed by the embedder as HostDefinedOptions to
    * the ScriptOrigin.
    */
+  V8_DEPRECATED("Use HostDefinedOptions")
   Local<PrimitiveArray> GetHostDefinedOptions();
+  Local<Data> HostDefinedOptions();
 };
 
 /**
@@ -170,29 +172,6 @@ class V8_EXPORT Module : public Data {
    */
   Local<Value> GetException() const;
 
-  /**
-   * Returns the number of modules requested by this module.
-   */
-  V8_DEPRECATE_SOON("Use Module::GetModuleRequests() and FixedArray::Length().")
-  int GetModuleRequestsLength() const;
-
-  /**
-   * Returns the ith module specifier in this module.
-   * i must be < GetModuleRequestsLength() and >= 0.
-   */
-  V8_DEPRECATE_SOON(
-      "Use Module::GetModuleRequests() and ModuleRequest::GetSpecifier().")
-  Local<String> GetModuleRequest(int i) const;
-
-  /**
-   * Returns the source location (line number and column number) of the ith
-   * module specifier's first occurrence in this module.
-   */
-  V8_DEPRECATE_SOON(
-      "Use Module::GetModuleRequests(), ModuleRequest::GetSourceOffset(), and "
-      "Module::SourceOffsetToLocation().")
-  Location GetModuleRequestLocation(int i) const;
-
   /**
    * Returns the ModuleRequests for this module.
    */
@@ -209,9 +188,6 @@ class V8_EXPORT Module : public Data {
    */
   int GetIdentityHash() const;
 
-  using ResolveCallback =
-      MaybeLocal<Module> (*)(Local<Context> context, Local<String> specifier,
-                             Local<Module> referrer);
   using ResolveModuleCallback = MaybeLocal<Module> (*)(
       Local<Context> context, Local<String> specifier,
       Local<FixedArray> import_assertions, Local<Module> referrer);
@@ -223,11 +199,6 @@ class V8_EXPORT Module : public Data {
    * instantiation. (In the case where the callback throws an exception, that
    * exception is propagated.)
    */
-  V8_DEPRECATE_SOON(
-      "Use the version of InstantiateModule that takes a ResolveModuleCallback "
-      "parameter")
-  V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule(Local<Context> context,
-                                                      ResolveCallback callback);
   V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule(
       Local<Context> context, ResolveModuleCallback callback);
 
@@ -340,11 +311,19 @@ class V8_EXPORT Script {
    * UnboundScript::BindToCurrentContext()).
    */
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> Run(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Run(Local<Context> context,
+                                              Local<Data> host_defined_options);
 
   /**
    * Returns the corresponding context-unbound script.
    */
   Local<UnboundScript> GetUnboundScript();
+
+  /**
+   * The name that was passed by the embedder as ResourceName to the
+   * ScriptOrigin. This can be either a v8::String or v8::Undefined.
+   */
+  Local<Value> GetResourceName();
 };
 
 enum class ScriptType { kClassic, kModule };
@@ -397,6 +376,7 @@ class V8_EXPORT ScriptCompiler {
   class Source {
    public:
     // Source takes ownership of both CachedData and CodeCacheConsumeTask.
+    // The caller *must* ensure that the cached data is from a trusted source.
     V8_INLINE Source(Local<String> source_string, const ScriptOrigin& origin,
                      CachedData* cached_data = nullptr,
                      ConsumeCodeCacheTask* consume_cache_task = nullptr);
@@ -424,7 +404,7 @@ class V8_EXPORT ScriptCompiler {
     int resource_column_offset;
     ScriptOriginOptions resource_options;
     Local<Value> source_map_url;
-    Local<PrimitiveArray> host_defined_options;
+    Local<Data> host_defined_options;
 
     // Cached data from previous compilation (if a kConsume*Cache flag is
     // set), or hold newly generated cache data (kProduce*Cache flags) are
@@ -463,23 +443,6 @@ class V8_EXPORT ScriptCompiler {
      * V8 has parsed the data it received so far.
      */
     virtual size_t GetMoreData(const uint8_t** src) = 0;
-
-    /**
-     * V8 calls this method to set a 'bookmark' at the current position in
-     * the source stream, for the purpose of (maybe) later calling
-     * ResetToBookmark. If ResetToBookmark is called later, then subsequent
-     * calls to GetMoreData should return the same data as they did when
-     * SetBookmark was called earlier.
-     *
-     * The embedder may return 'false' to indicate it cannot provide this
-     * functionality.
-     */
-    virtual bool SetBookmark();
-
-    /**
-     * V8 calls this to return to a previously set bookmark.
-     */
-    virtual void ResetToBookmark();
   };
 
   /**
@@ -694,6 +657,12 @@ class V8_EXPORT ScriptCompiler {
       CompileOptions options = kNoCompileOptions,
       NoCacheReason no_cache_reason = kNoCacheNoReason,
       Local<ScriptOrModule>* script_or_module_out = nullptr);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunction(
+      Local<Context> context, Source* source, size_t arguments_count = 0,
+      Local<String> arguments[] = nullptr, size_t context_extension_count = 0,
+      Local<Object> context_extensions[] = nullptr,
+      CompileOptions options = kNoCompileOptions,
+      NoCacheReason no_cache_reason = kNoCacheNoReason);
 
   /**
    * Creates and returns code cache for the specified unbound_script.
@@ -712,7 +681,7 @@ class V8_EXPORT ScriptCompiler {
 
   /**
    * Creates and returns code cache for the specified function that was
-   * previously produced by CompileFunctionInContext.
+   * previously produced by CompileFunction.
    * This will return nullptr if the script cannot be serialized. The
    * CachedData returned by this function should be owned by the caller.
    */
@@ -722,6 +691,13 @@ class V8_EXPORT ScriptCompiler {
   static V8_WARN_UNUSED_RESULT MaybeLocal<UnboundScript> CompileUnboundInternal(
       Isolate* isolate, Source* source, CompileOptions options,
       NoCacheReason no_cache_reason);
+
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInternal(
+      Local<Context> context, Source* source, size_t arguments_count,
+      Local<String> arguments[], size_t context_extension_count,
+      Local<Object> context_extensions[], CompileOptions options,
+      NoCacheReason no_cache_reason,
+      Local<ScriptOrModule>* script_or_module_out);
 };
 
 ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin,
@@ -733,7 +709,7 @@ ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin,
       resource_column_offset(origin.ColumnOffset()),
       resource_options(origin.Options()),
       source_map_url(origin.SourceMapUrl()),
-      host_defined_options(origin.HostDefinedOptions()),
+      host_defined_options(origin.GetHostDefinedOptions()),
       cached_data(data),
       consume_cache_task(consume_cache_task) {}
 

data/vendor/v8/include/v8-snapshot.h

@@ -5,8 +5,6 @@
 #ifndef INCLUDE_V8_SNAPSHOT_H_
 #define INCLUDE_V8_SNAPSHOT_H_
 
-#include <vector>
-
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)

data/vendor/v8/include/v8-statistics.h

@@ -201,11 +201,13 @@ class V8_EXPORT HeapCodeStatistics {
   size_t code_and_metadata_size() { return code_and_metadata_size_; }
   size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }
   size_t external_script_source_size() { return external_script_source_size_; }
+  size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; }
 
  private:
   size_t code_and_metadata_size_;
   size_t bytecode_and_metadata_size_;
   size_t external_script_source_size_;
+  size_t cpu_profiler_metadata_size_;
 
   friend class Isolate;
 };

data/vendor/v8/include/v8-template.h

@@ -89,11 +89,26 @@ class V8_EXPORT Template : public Data {
    *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
    *   thrown and no callback is invoked.
    */
+  V8_DEPRECATED("Do signature check in accessor")
+  void SetNativeDataProperty(
+      Local<String> name, AccessorGetterCallback getter,
+      AccessorSetterCallback setter, Local<Value> data,
+      PropertyAttribute attribute, Local<AccessorSignature> signature,
+      AccessControl settings = DEFAULT,
+      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
+  V8_DEPRECATED("Do signature check in accessor")
+  void SetNativeDataProperty(
+      Local<Name> name, AccessorNameGetterCallback getter,
+      AccessorNameSetterCallback setter, Local<Value> data,
+      PropertyAttribute attribute, Local<AccessorSignature> signature,
+      AccessControl settings = DEFAULT,
+      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetNativeDataProperty(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
       Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
-      Local<AccessorSignature> signature = Local<AccessorSignature>(),
       AccessControl settings = DEFAULT,
       SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
       SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
@@ -101,7 +116,6 @@ class V8_EXPORT Template : public Data {
       Local<Name> name, AccessorNameGetterCallback getter,
       AccessorNameSetterCallback setter = nullptr,
       Local<Value> data = Local<Value>(), PropertyAttribute attribute = None,
-      Local<AccessorSignature> signature = Local<AccessorSignature>(),
       AccessControl settings = DEFAULT,
       SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
       SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
@@ -813,12 +827,26 @@ class V8_EXPORT ObjectTemplate : public Template {
    *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
    *   thrown and no callback is invoked.
    */
+  V8_DEPRECATED("Do signature check in accessor")
+  void SetAccessor(
+      Local<String> name, AccessorGetterCallback getter,
+      AccessorSetterCallback setter, Local<Value> data, AccessControl settings,
+      PropertyAttribute attribute, Local<AccessorSignature> signature,
+      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
+  V8_DEPRECATED("Do signature check in accessor")
+  void SetAccessor(
+      Local<Name> name, AccessorNameGetterCallback getter,
+      AccessorNameSetterCallback setter, Local<Value> data,
+      AccessControl settings, PropertyAttribute attribute,
+      Local<AccessorSignature> signature,
+      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
+      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetAccessor(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
       Local<Value> data = Local<Value>(), AccessControl settings = DEFAULT,
       PropertyAttribute attribute = None,
-      Local<AccessorSignature> signature = Local<AccessorSignature>(),
       SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
       SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetAccessor(
@@ -826,7 +854,6 @@ class V8_EXPORT ObjectTemplate : public Template {
       AccessorNameSetterCallback setter = nullptr,
       Local<Value> data = Local<Value>(), AccessControl settings = DEFAULT,
       PropertyAttribute attribute = None,
-      Local<AccessorSignature> signature = Local<AccessorSignature>(),
       SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
       SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 

data/vendor/v8/include/v8-traced-handle.h

@@ -11,10 +11,8 @@
 
 #include <atomic>
 #include <memory>
-#include <string>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "v8-internal.h"            // NOLINT(build/include_directory)
 #include "v8-local-handle.h"        // NOLINT(build/include_directory)
@@ -26,28 +24,24 @@ namespace v8 {
 class Value;
 
 namespace internal {
+
 class BasicTracedReferenceExtractor;
-}  // namespace internal
 
-namespace api_internal {
+enum class GlobalHandleStoreMode {
+  kInitializingStore,
+  kAssigningStore,
+};
+
 V8_EXPORT internal::Address* GlobalizeTracedReference(
     internal::Isolate* isolate, internal::Address* handle,
-    internal::Address* slot, bool has_destructor);
-V8_EXPORT void MoveTracedGlobalReference(internal::Address** from,
-                                         internal::Address** to);
-V8_EXPORT void CopyTracedGlobalReference(const internal::Address* const* from,
-                                         internal::Address** to);
-V8_EXPORT void DisposeTracedGlobal(internal::Address* global_handle);
-V8_EXPORT void SetFinalizationCallbackTraced(
-    internal::Address* location, void* parameter,
-    WeakCallbackInfo<void>::Callback callback);
-}  // namespace api_internal
+    internal::Address* slot, GlobalHandleStoreMode store_mode);
+V8_EXPORT void MoveTracedReference(internal::Address** from,
+                                   internal::Address** to);
+V8_EXPORT void CopyTracedReference(const internal::Address* const* from,
+                                   internal::Address** to);
+V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
 
-/**
- * Deprecated. Use |TracedReference<T>| instead.
- */
-template <typename T>
-struct TracedGlobalTrait {};
+}  // namespace internal
 
 class TracedReferenceBase {
  public:
@@ -132,9 +126,8 @@ class TracedReferenceBase {
  *   |v8::EmbedderRootsHandler::IsRoot()| whether the handle should
  * be treated as root or not.
  *
- * Note that the base class cannot be instantiated itself. Choose from
- * - TracedGlobal
- * - TracedReference
+ * Note that the base class cannot be instantiated itself, use |TracedReference|
+ * instead.
  */
 template <typename T>
 class BasicTracedReference : public TracedReferenceBase {
@@ -164,23 +157,20 @@ class BasicTracedReference : public TracedReferenceBase {
   }
 
  private:
-  enum DestructionMode { kWithDestructor, kWithoutDestructor };
-
   /**
    * An empty BasicTracedReference without storage cell.
    */
   BasicTracedReference() = default;
 
-  V8_INLINE static internal::Address* New(Isolate* isolate, T* that, void* slot,
-                                          DestructionMode destruction_mode);
+  V8_INLINE static internal::Address* New(
+      Isolate* isolate, T* that, void* slot,
+      internal::GlobalHandleStoreMode store_mode);
 
   friend class EmbedderHeapTracer;
   template <typename F>
   friend class Local;
   friend class Object;
   template <typename F>
-  friend class TracedGlobal;
-  template <typename F>
   friend class TracedReference;
   template <typename F>
   friend class BasicTracedReference;
@@ -188,127 +178,6 @@ class BasicTracedReference : public TracedReferenceBase {
   friend class ReturnValue;
 };
 
-/**
- * A traced handle with destructor that clears the handle. For more details see
- * BasicTracedReference.
- */
-template <typename T>
-class TracedGlobal : public BasicTracedReference<T> {
- public:
-  using BasicTracedReference<T>::Reset;
-
-  /**
-   * Destructor resetting the handle.Is
-   */
-  ~TracedGlobal() { this->Reset(); }
-
-  /**
-   * An empty TracedGlobal without storage cell.
-   */
-  TracedGlobal() : BasicTracedReference<T>() {}
-
-  /**
-   * Construct a TracedGlobal from a Local.
-   *
-   * When the Local is non-empty, a new storage cell is created
-   * pointing to the same object.
-   */
-  template <class S>
-  TracedGlobal(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->val_ = this->New(isolate, that.val_, &this->val_,
-                           BasicTracedReference<T>::kWithDestructor);
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
-
-  /**
-   * Move constructor initializing TracedGlobal from an existing one.
-   */
-  V8_INLINE TracedGlobal(TracedGlobal&& other) {
-    // Forward to operator=.
-    *this = std::move(other);
-  }
-
-  /**
-   * Move constructor initializing TracedGlobal from an existing one.
-   */
-  template <typename S>
-  V8_INLINE TracedGlobal(TracedGlobal<S>&& other) {
-    // Forward to operator=.
-    *this = std::move(other);
-  }
-
-  /**
-   * Copy constructor initializing TracedGlobal from an existing one.
-   */
-  V8_INLINE TracedGlobal(const TracedGlobal& other) {
-    // Forward to operator=;
-    *this = other;
-  }
-
-  /**
-   * Copy constructor initializing TracedGlobal from an existing one.
-   */
-  template <typename S>
-  V8_INLINE TracedGlobal(const TracedGlobal<S>& other) {
-    // Forward to operator=;
-    *this = other;
-  }
-
-  /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
-   */
-  V8_INLINE TracedGlobal& operator=(TracedGlobal&& rhs);
-
-  /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
-   */
-  template <class S>
-  V8_INLINE TracedGlobal& operator=(TracedGlobal<S>&& rhs);
-
-  /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
-   *
-   * Note: Prohibited when |other| has a finalization callback set through
-   * |SetFinalizationCallback|.
-   */
-  V8_INLINE TracedGlobal& operator=(const TracedGlobal& rhs);
-
-  /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
-   *
-   * Note: Prohibited when |other| has a finalization callback set through
-   * |SetFinalizationCallback|.
-   */
-  template <class S>
-  V8_INLINE TracedGlobal& operator=(const TracedGlobal<S>& rhs);
-
-  /**
-   * If non-empty, destroy the underlying storage cell and create a new one with
-   * the contents of other if other is non empty
-   */
-  template <class S>
-  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
-
-  template <class S>
-  V8_INLINE TracedGlobal<S>& As() const {
-    return reinterpret_cast<TracedGlobal<S>&>(
-        const_cast<TracedGlobal<T>&>(*this));
-  }
-
-  /**
-   * Adds a finalization callback to the handle. The type of this callback is
-   * similar to WeakCallbackType::kInternalFields, i.e., it will pass the
-   * parameter and the first two internal fields of the object.
-   *
-   * The callback is then supposed to reset the handle in the callback. No
-   * further V8 API may be called in this callback. In case additional work
-   * involving V8 needs to be done, a second callback can be scheduled using
-   * WeakCallbackInfo<void>::SetSecondPassCallback.
-   */
-  V8_INLINE void SetFinalizationCallback(
-      void* parameter, WeakCallbackInfo<void>::Callback callback);
-};
-
 /**
  * A traced handle without destructor that clears the handle. The embedder needs
  * to ensure that the handle is not accessed once the V8 object has been
@@ -339,7 +208,7 @@ class TracedReference : public BasicTracedReference<T> {
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
     this->val_ = this->New(isolate, that.val_, &this->val_,
-                           BasicTracedReference<T>::kWithoutDestructor);
+                           internal::GlobalHandleStoreMode::kInitializingStore);
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -347,7 +216,7 @@ class TracedReference : public BasicTracedReference<T> {
    * Move constructor initializing TracedReference from an
    * existing one.
    */
-  V8_INLINE TracedReference(TracedReference&& other) {
+  V8_INLINE TracedReference(TracedReference&& other) noexcept {
     // Forward to operator=.
     *this = std::move(other);
   }
@@ -357,7 +226,7 @@ class TracedReference : public BasicTracedReference<T> {
    * existing one.
    */
   template <typename S>
-  V8_INLINE TracedReference(TracedReference<S>&& other) {
+  V8_INLINE TracedReference(TracedReference<S>&& other) noexcept {
     // Forward to operator=.
     *this = std::move(other);
   }
@@ -382,23 +251,23 @@ class TracedReference : public BasicTracedReference<T> {
   }
 
   /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
+   * Move assignment operator initializing TracedReference from an existing one.
    */
-  V8_INLINE TracedReference& operator=(TracedReference&& rhs);
+  V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept;
 
   /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
+   * Move assignment operator initializing TracedReference from an existing one.
    */
   template <class S>
-  V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs);
+  V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs) noexcept;
 
   /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
+   * Copy assignment operator initializing TracedReference from an existing one.
    */
   V8_INLINE TracedReference& operator=(const TracedReference& rhs);
 
   /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
+   * Copy assignment operator initializing TracedReference from an existing one.
    */
   template <class S>
   V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs);
@@ -420,18 +289,18 @@ class TracedReference : public BasicTracedReference<T> {
 // --- Implementation ---
 template <class T>
 internal::Address* BasicTracedReference<T>::New(
-    Isolate* isolate, T* that, void* slot, DestructionMode destruction_mode) {
+    Isolate* isolate, T* that, void* slot,
+    internal::GlobalHandleStoreMode store_mode) {
   if (that == nullptr) return nullptr;
   internal::Address* p = reinterpret_cast<internal::Address*>(that);
-  return api_internal::GlobalizeTracedReference(
+  return internal::GlobalizeTracedReference(
       reinterpret_cast<internal::Isolate*>(isolate), p,
-      reinterpret_cast<internal::Address*>(slot),
-      destruction_mode == kWithDestructor);
+      reinterpret_cast<internal::Address*>(slot), store_mode);
 }
 
 void TracedReferenceBase::Reset() {
   if (IsEmpty()) return;
-  api_internal::DisposeTracedGlobal(reinterpret_cast<internal::Address*>(val_));
+  internal::DisposeTracedReference(reinterpret_cast<internal::Address*>(val_));
   SetSlotThreadSafe(nullptr);
 }
 
@@ -477,55 +346,6 @@ V8_INLINE bool operator!=(const v8::Local<U>& lhs,
   return !(rhs == lhs);
 }
 
-template <class T>
-template <class S>
-void TracedGlobal<T>::Reset(Isolate* isolate, const Local<S>& other) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
-  Reset();
-  if (other.IsEmpty()) return;
-  this->val_ = this->New(isolate, other.val_, &this->val_,
-                         BasicTracedReference<T>::kWithDestructor);
-}
-
-template <class T>
-template <class S>
-TracedGlobal<T>& TracedGlobal<T>::operator=(TracedGlobal<S>&& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
-  *this = std::move(rhs.template As<T>());
-  return *this;
-}
-
-template <class T>
-template <class S>
-TracedGlobal<T>& TracedGlobal<T>::operator=(const TracedGlobal<S>& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
-  *this = rhs.template As<T>();
-  return *this;
-}
-
-template <class T>
-TracedGlobal<T>& TracedGlobal<T>::operator=(TracedGlobal&& rhs) {
-  if (this != &rhs) {
-    api_internal::MoveTracedGlobalReference(
-        reinterpret_cast<internal::Address**>(&rhs.val_),
-        reinterpret_cast<internal::Address**>(&this->val_));
-  }
-  return *this;
-}
-
-template <class T>
-TracedGlobal<T>& TracedGlobal<T>::operator=(const TracedGlobal& rhs) {
-  if (this != &rhs) {
-    this->Reset();
-    if (rhs.val_ != nullptr) {
-      api_internal::CopyTracedGlobalReference(
-          reinterpret_cast<const internal::Address* const*>(&rhs.val_),
-          reinterpret_cast<internal::Address**>(&this->val_));
-    }
-  }
-  return *this;
-}
-
 template <class T>
 template <class S>
 void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
@@ -534,12 +354,13 @@ void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   if (other.IsEmpty()) return;
   this->SetSlotThreadSafe(
       this->New(isolate, other.val_, &this->val_,
-                BasicTracedReference<T>::kWithoutDestructor));
+                internal::GlobalHandleStoreMode::kAssigningStore));
 }
 
 template <class T>
 template <class S>
-TracedReference<T>& TracedReference<T>::operator=(TracedReference<S>&& rhs) {
+TracedReference<T>& TracedReference<T>::operator=(
+    TracedReference<S>&& rhs) noexcept {
   static_assert(std::is_base_of<T, S>::value, "type check");
   *this = std::move(rhs.template As<T>());
   return *this;
@@ -555,9 +376,10 @@ TracedReference<T>& TracedReference<T>::operator=(
 }
 
 template <class T>
-TracedReference<T>& TracedReference<T>::operator=(TracedReference&& rhs) {
+TracedReference<T>& TracedReference<T>::operator=(
+    TracedReference&& rhs) noexcept {
   if (this != &rhs) {
-    api_internal::MoveTracedGlobalReference(
+    internal::MoveTracedReference(
         reinterpret_cast<internal::Address**>(&rhs.val_),
         reinterpret_cast<internal::Address**>(&this->val_));
   }
@@ -569,7 +391,7 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   if (this != &rhs) {
     this->Reset();
     if (rhs.val_ != nullptr) {
-      api_internal::CopyTracedGlobalReference(
+      internal::CopyTracedReference(
           reinterpret_cast<const internal::Address* const*>(&rhs.val_),
           reinterpret_cast<internal::Address**>(&this->val_));
     }
@@ -593,13 +415,6 @@ uint16_t TracedReferenceBase::WrapperClassId() const {
   return *reinterpret_cast<uint16_t*>(addr);
 }
 
-template <class T>
-void TracedGlobal<T>::SetFinalizationCallback(
-    void* parameter, typename WeakCallbackInfo<void>::Callback callback) {
-  api_internal::SetFinalizationCallbackTraced(
-      reinterpret_cast<internal::Address*>(this->val_), parameter, callback);
-}
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_TRACED_HANDLE_H_