libv8-node 19.9.0.0-x86_64-linux → 20.12.1.0-x86_64-linux

data/vendor/v8/include/cppgc/platform.h

@@ -33,8 +33,9 @@ class V8_EXPORT Platform {
   virtual ~Platform() = default;
 
   /**
-   * Returns the allocator used by cppgc to allocate its heap and various
-   * support structures.
+   * \returns the allocator used by cppgc to allocate its heap and various
+   * support structures. Returning nullptr results in using the `PageAllocator`
+   * provided by `cppgc::InitializeProcess()` instead.
    */
   virtual PageAllocator* GetPageAllocator() = 0;
 
@@ -133,9 +134,10 @@ class V8_EXPORT Platform {
  * Can be called multiple times when paired with `ShutdownProcess()`.
  *
  * \param page_allocator The allocator used for maintaining meta data. Must stay
- *   always alive and not change between multiple calls to InitializeProcess.
+ *   always alive and not change between multiple calls to InitializeProcess. If
+ *   no allocator is provided, a default internal version will be used.
  */
-V8_EXPORT void InitializeProcess(PageAllocator* page_allocator);
+V8_EXPORT void InitializeProcess(PageAllocator* page_allocator = nullptr);
 
 /**
  * Must be called after destroying the last used heap. Some process-global

data/vendor/v8/include/cppgc/type-traits.h

@@ -16,7 +16,7 @@ class Visitor;
 
 namespace internal {
 template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-          typename CheckingPolicy>
+          typename CheckingPolicy, typename StorageType>
 class BasicMember;
 struct DijkstraWriteBarrierPolicy;
 struct NoWriteBarrierPolicy;
@@ -126,9 +126,10 @@ template <typename BasicMemberCandidate, typename WeaknessTag,
           typename WriteBarrierPolicy>
 struct IsSubclassOfBasicMemberTemplate {
  private:
-  template <typename T, typename CheckingPolicy>
+  template <typename T, typename CheckingPolicy, typename StorageType>
   static std::true_type SubclassCheck(
-      BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy>*);
+      BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy,
+                  StorageType>*);
   static std::false_type SubclassCheck(...);
 
  public:

data/vendor/v8/include/cppgc/visitor.h

@@ -99,6 +99,20 @@ class V8_EXPORT Visitor {
               &HandleWeak<WeakMember<T>>, &weak_member);
   }
 
+#if defined(CPPGC_POINTER_COMPRESSION)
+  /**
+   * Trace method for UncompressedMember.
+   *
+   * \param member UncompressedMember reference retaining an object.
+   */
+  template <typename T>
+  void Trace(const subtle::UncompressedMember<T>& member) {
+    const T* value = member.GetRawAtomic();
+    CPPGC_DCHECK(value != kSentinelPointer);
+    TraceImpl(value);
+  }
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
   /**
    * Trace method for inlined objects that are not allocated themselves but
    * otherwise follow managed heap layout and have a Trace() method.
@@ -229,7 +243,8 @@ class V8_EXPORT Visitor {
   }
 
   /**
-   * Trace method for retaining containers weakly.
+   * Trace method for retaining containers weakly. Note that weak containers
+   * should emit write barriers.
    *
    * \param object reference to the container.
    * \param callback to be invoked.

data/vendor/v8/include/libplatform/v8-tracing.h

@@ -282,12 +282,12 @@ class V8_PLATFORM_EXPORT TracingController
                                 const char* name, uint64_t handle) override;
 
   static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
-#endif  // !defined(V8_USE_PERFETTO)
 
   void AddTraceStateObserver(
       v8::TracingController::TraceStateObserver* observer) override;
   void RemoveTraceStateObserver(
       v8::TracingController::TraceStateObserver* observer) override;
+#endif  // !defined(V8_USE_PERFETTO)
 
   void StartTracing(TraceConfig* trace_config);
   void StopTracing();
@@ -307,7 +307,6 @@ class V8_PLATFORM_EXPORT TracingController
   std::unique_ptr<base::Mutex> mutex_;
   std::unique_ptr<TraceConfig> trace_config_;
   std::atomic_bool recording_{false};
-  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
 
 #if defined(V8_USE_PERFETTO)
   std::ostream* output_stream_ = nullptr;
@@ -316,6 +315,7 @@ class V8_PLATFORM_EXPORT TracingController
   TraceEventListener* listener_for_testing_ = nullptr;
   std::unique_ptr<perfetto::TracingSession> tracing_session_;
 #else   // !defined(V8_USE_PERFETTO)
+  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
   std::unique_ptr<TraceBuffer> trace_buffer_;
 #endif  // !defined(V8_USE_PERFETTO)
 

data/vendor/v8/include/v8-array-buffer.h

@@ -53,12 +53,28 @@ class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase {
    */
   size_t ByteLength() const;
 
+  /**
+   * The maximum length (in bytes) that this backing store may grow to.
+   *
+   * If this backing store was created for a resizable ArrayBuffer or a growable
+   * SharedArrayBuffer, it is >= ByteLength(). Otherwise it is ==
+   * ByteLength().
+   */
+  size_t MaxByteLength() const;
+
   /**
    * Indicates whether the backing store was created for an ArrayBuffer or
    * a SharedArrayBuffer.
    */
   bool IsShared() const;
 
+  /**
+   * Indicates whether the backing store was created for a resizable ArrayBuffer
+   * or a growable SharedArrayBuffer, and thus may be resized by user JavaScript
+   * code.
+   */
+  bool IsResizableByUserJavaScript() const;
+
   /**
    * Prevent implicit instantiation of operator delete with size_t argument.
    * The size_t argument would be incorrect because ptr points to the
@@ -189,6 +205,11 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   size_t ByteLength() const;
 
+  /**
+   * Maximum length in bytes.
+   */
+  size_t MaxByteLength() const;
+
   /**
    * Create a new ArrayBuffer. Allocate |byte_length| bytes.
    * Allocated memory will be owned by a created ArrayBuffer and
@@ -235,6 +256,21 @@ class V8_EXPORT ArrayBuffer : public Object {
       void* data, size_t byte_length, v8::BackingStore::DeleterCallback deleter,
       void* deleter_data);
 
+  /**
+   * Returns a new resizable standalone BackingStore that is allocated using the
+   * array buffer allocator of the isolate. The result can be later passed to
+   * ArrayBuffer::New.
+   *
+   * |byte_length| must be <= |max_byte_length|.
+   *
+   * This function is usable without an isolate. Unlike |NewBackingStore| calls
+   * with an isolate, GCs cannot be triggered, and there are no
+   * retries. Allocation failure will cause the function to crash with an
+   * out-of-memory error.
+   */
+  static std::unique_ptr<BackingStore> NewResizableBackingStore(
+      size_t byte_length, size_t max_byte_length);
+
   /**
    * Returns true if this ArrayBuffer may be detached.
    */
@@ -251,8 +287,26 @@ class V8_EXPORT ArrayBuffer : public Object {
    * preventing JavaScript from ever accessing underlying backing store.
    * ArrayBuffer should have been externalized and must be detachable.
    */
+  V8_DEPRECATE_SOON(
+      "Use the version which takes a key parameter (passing a null handle is "
+      "ok).")
   void Detach();
 
+  /**
+   * Detaches this ArrayBuffer and all its views (typed arrays).
+   * Detaching sets the byte length of the buffer and all typed arrays to zero,
+   * preventing JavaScript from ever accessing underlying backing store.
+   * ArrayBuffer should have been externalized and must be detachable. Returns
+   * Nothing if the key didn't pass the [[ArrayBufferDetachKey]] check,
+   * Just(true) otherwise.
+   */
+  V8_WARN_UNUSED_RESULT Maybe<bool> Detach(v8::Local<v8::Value> key);
+
+  /**
+   * Sets the ArrayBufferDetachKey.
+   */
+  void SetDetachKey(v8::Local<v8::Value> key);
+
   /**
    * Get a shared pointer to the backing store of this array buffer. This
    * pointer coordinates the lifetime management of the internal storage
@@ -374,6 +428,11 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    */
   size_t ByteLength() const;
 
+  /**
+   * Maximum length in bytes.
+   */
+  size_t MaxByteLength() const;
+
   /**
    * Create a new SharedArrayBuffer. Allocate |byte_length| bytes.
    * Allocated memory will be owned by a created SharedArrayBuffer and

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

@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 
+#include <functional>
 #include <string>
 
 #include "cppgc/common.h"
@@ -237,7 +238,8 @@ using LogEventCallback = void (*)(const char* name,
 enum class CrashKeyId {
   kIsolateAddress,
   kReadonlySpaceFirstPageAddress,
-  kMapSpaceFirstPageAddress,
+  kMapSpaceFirstPageAddress V8_ENUM_DEPRECATE_SOON("Map space got removed"),
+  kOldSpaceFirstPageAddress,
   kCodeRangeBaseAddress,
   kCodeSpaceFirstPageAddress,
   kDumpType,
@@ -327,6 +329,10 @@ using WasmSimdEnabledCallback = bool (*)(Local<Context> context);
 // --- Callback for checking if WebAssembly exceptions are enabled ---
 using WasmExceptionsEnabledCallback = bool (*)(Local<Context> context);
 
+// --- Callback for checking if WebAssembly GC is enabled ---
+// If the callback returns true, it will also enable Wasm stringrefs.
+using WasmGCEnabledCallback = bool (*)(Local<Context> context);
+
 // --- Callback for checking if the SharedArrayBuffer constructor is enabled ---
 using SharedArrayBufferConstructorEnabledCallback =
     bool (*)(Local<Context> context);
@@ -367,6 +373,13 @@ using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)(
     Local<Value> resource_name, Local<String> specifier,
     Local<FixedArray> import_assertions);
 
+/**
+ * Callback for requesting a compile hint for a function from the embedder. The
+ * first parameter is the position of the function in source code and the second
+ * parameter is embedder data to be passed back.
+ */
+using CompileHintCallback = bool (*)(int, void*);
+
 /**
  * HostInitializeImportMetaObjectCallback is called the first time import.meta
  * is accessed for a module. Subsequent access will reuse the same value.

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

@@ -7,8 +7,11 @@
 
 #include <stdint.h>
 
+#include <vector>
+
 #include "v8-data.h"          // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-maybe.h"         // NOLINT(build/include_directory)
 #include "v8-snapshot.h"      // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -163,12 +166,51 @@ class V8_EXPORT Context : public Data {
    */
   void Exit();
 
+  /**
+   * Delegate to help with Deep freezing embedder-specific objects (such as
+   * JSApiObjects) that can not be frozen natively.
+   */
+  class DeepFreezeDelegate {
+   public:
+    /**
+     * Performs embedder-specific operations to freeze the provided embedder
+     * object. The provided object *will* be frozen by DeepFreeze after this
+     * function returns, so only embedder-specific objects need to be frozen.
+     * This function *may not* create new JS objects or perform JS allocations.
+     * Any v8 objects reachable from the provided embedder object that should
+     * also be considered for freezing should be added to the children_out
+     * parameter. Returns true if the operation completed successfully.
+     */
+    virtual bool FreezeEmbedderObjectAndGetChildren(
+        Local<Object> obj, std::vector<Local<Object>>& children_out) = 0;
+  };
+
+  /**
+   * Attempts to recursively freeze all objects reachable from this context.
+   * Some objects (generators, iterators, non-const closures) can not be frozen
+   * and will cause this method to throw an error. An optional delegate can be
+   * provided to help freeze embedder-specific objects.
+   *
+   * Freezing occurs in two steps:
+   * 1. "Marking" where we iterate through all objects reachable by this
+   *    context, accumulating a list of objects that need to be frozen and
+   *    looking for objects that can't be frozen. This step is separated because
+   *    it is more efficient when we can assume there is no garbage collection.
+   * 2. "Freezing" where we go through the list of objects and freezing them.
+   *    This effectively requires copying them so it may trigger garbage
+   *    collection.
+   */
+  Maybe<void> DeepFreeze(DeepFreezeDelegate* delegate = nullptr);
+
   /** Returns the isolate associated with a current context. */
   Isolate* GetIsolate();
 
   /** Returns the microtask queue associated with a current context. */
   MicrotaskQueue* GetMicrotaskQueue();
 
+  /** Sets the microtask queue associated with the current context. */
+  void SetMicrotaskQueue(MicrotaskQueue* queue);
+
   /**
    * The field at kDebugIdIndex used to be reserved for the inspector.
    * It now serves no purpose.
@@ -362,13 +404,18 @@ Local<Value> Context::GetEmbedderData(int index) {
 #ifdef V8_COMPRESS_POINTERS
   // We read the full pointer value and then decompress it in order to avoid
   // dealing with potential endiannes issues.
-  value =
-      I::DecompressTaggedAnyField(embedder_data, static_cast<uint32_t>(value));
+  value = I::DecompressTaggedField(embedder_data, static_cast<uint32_t>(value));
 #endif
+
+#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+  return Local<Value>(reinterpret_cast<Value*>(value));
+#else
   internal::Isolate* isolate = internal::IsolateFromNeverReadOnlySpaceObject(
       *reinterpret_cast<A*>(this));
   A* result = HandleScope::CreateHandle(isolate, value);
   return Local<Value>(reinterpret_cast<Value*>(result));
+#endif
+
 #else
   return SlowGetEmbedderData(index);
 #endif
@@ -378,7 +425,7 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
   using I = internal::Internals;
-  A ctx = *reinterpret_cast<const A*>(this);
+  A ctx = internal::ValueHelper::ValueAsAddress(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
   int value_offset = I::kEmbedderDataArrayHeaderSize +

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

@@ -77,6 +77,12 @@ struct WrapperDescriptor final {
 };
 
 struct V8_EXPORT CppHeapCreateParams {
+  CppHeapCreateParams(
+      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,
+      WrapperDescriptor wrapper_descriptor)
+      : custom_spaces(std::move(custom_spaces)),
+        wrapper_descriptor(wrapper_descriptor) {}
+
   CppHeapCreateParams(const CppHeapCreateParams&) = delete;
   CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;
 
@@ -98,6 +104,10 @@ struct V8_EXPORT CppHeapCreateParams {
 
 /**
  * A heap for allocating managed C++ objects.
+ *
+ * Similar to v8::Isolate, the heap may only be accessed from one thread at a
+ * time. The heap may be used from different threads using the
+ * v8::Locker/v8::Unlocker APIs which is different from generic Oilpan.
  */
 class V8_EXPORT CppHeap {
  public:
@@ -167,6 +177,11 @@ class V8_EXPORT CppHeap {
   void CollectGarbageInYoungGenerationForTesting(
       cppgc::EmbedderStackState stack_state);
 
+  /**
+   * \returns the wrapper descriptor of this CppHeap.
+   */
+  v8::WrapperDescriptor wrapper_descriptor() const;
+
  private:
   CppHeap() = default;
 

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

@@ -53,7 +53,7 @@ class V8_EXPORT Data {
   bool IsContext() const;
 
  private:
-  Data();
+  Data() = delete;
 };
 
 /**

data/vendor/v8/include/v8-embedder-heap.h

@@ -5,27 +5,14 @@
 #ifndef INCLUDE_V8_EMBEDDER_HEAP_H_
 #define INCLUDE_V8_EMBEDDER_HEAP_H_
 
-#include <stddef.h>
-#include <stdint.h>
-
-#include <utility>
-#include <vector>
-
-#include "cppgc/common.h"
-#include "v8-local-handle.h"   // NOLINT(build/include_directory)
 #include "v8-traced-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"          // NOLINT(build/include_directory)
 
 namespace v8 {
 
-class Data;
 class Isolate;
 class Value;
 
-namespace internal {
-class LocalEmbedderHeapTracer;
-}  // namespace internal
-
 /**
  * Handler for embedder roots on non-unified heap garbage collections.
  */
@@ -62,162 +49,6 @@ class V8_EXPORT EmbedderRootsHandler {
   virtual void ResetRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 };
 
-/**
- * Interface for tracing through the embedder heap. During a V8 garbage
- * collection, V8 collects hidden fields of all potential wrappers, and at the
- * end of its marking phase iterates the collection and asks the embedder to
- * trace through its heap and use reporter to report each JavaScript object
- * reachable from any of the given wrappers.
- */
-class V8_EXPORT
-// GCC doesn't like combining __attribute__(()) with [[deprecated]].
-#ifdef __clang__
-V8_DEPRECATE_SOON("Use CppHeap when working with v8::TracedReference.")
-#endif  // __clang__
-    EmbedderHeapTracer {
- public:
-  using EmbedderStackState = cppgc::EmbedderStackState;
-
-  enum TraceFlags : uint64_t {
-    kNoFlags = 0,
-    kReduceMemory = 1 << 0,
-    kForced = 1 << 2,
-  };
-
-  /**
-   * Interface for iterating through |TracedReference| handles.
-   */
-  class V8_EXPORT TracedGlobalHandleVisitor {
-   public:
-    virtual ~TracedGlobalHandleVisitor() = default;
-    virtual void VisitTracedReference(const TracedReference<Value>& handle) {}
-  };
-
-  /**
-   * Summary of a garbage collection cycle. See |TraceEpilogue| on how the
-   * summary is reported.
-   */
-  struct TraceSummary {
-    /**
-     * Time spent managing the retained memory in milliseconds. This can e.g.
-     * include the time tracing through objects in the embedder.
-     */
-    double time = 0.0;
-
-    /**
-     * Memory retained by the embedder through the |EmbedderHeapTracer|
-     * mechanism in bytes.
-     */
-    size_t allocated_size = 0;
-  };
-
-  virtual ~EmbedderHeapTracer() = default;
-
-  /**
-   * Iterates all |TracedReference| handles created for the |v8::Isolate| the
-   * tracer is attached to.
-   */
-  void IterateTracedGlobalHandles(TracedGlobalHandleVisitor* visitor);
-
-  /**
-   * Called by the embedder to set the start of the stack which is e.g. used by
-   * V8 to determine whether handles are used from stack or heap.
-   */
-  void SetStackStart(void* stack_start);
-
-  /**
-   * Called by v8 to register internal fields of found wrappers.
-   *
-   * The embedder is expected to store them somewhere and trace reachable
-   * wrappers from them when called through |AdvanceTracing|.
-   */
-  virtual void RegisterV8References(
-      const std::vector<std::pair<void*, void*>>& embedder_fields) = 0;
-
-  void RegisterEmbedderReference(const BasicTracedReference<v8::Data>& ref);
-
-  /**
-   * Called at the beginning of a GC cycle.
-   */
-  virtual void TracePrologue(TraceFlags flags) {}
-
-  /**
-   * Called to advance tracing in the embedder.
-   *
-   * The embedder is expected to trace its heap starting from wrappers reported
-   * by RegisterV8References method, and report back all reachable wrappers.
-   * Furthermore, the embedder is expected to stop tracing by the given
-   * deadline. A deadline of infinity means that tracing should be finished.
-   *
-   * Returns |true| if tracing is done, and false otherwise.
-   */
-  virtual bool AdvanceTracing(double deadline_in_ms) = 0;
-
-  /*
-   * Returns true if there no more tracing work to be done (see AdvanceTracing)
-   * and false otherwise.
-   */
-  virtual bool IsTracingDone() = 0;
-
-  /**
-   * Called at the end of a GC cycle.
-   *
-   * Note that allocation is *not* allowed within |TraceEpilogue|. Can be
-   * overriden to fill a |TraceSummary| that is used by V8 to schedule future
-   * garbage collections.
-   */
-  virtual void TraceEpilogue(TraceSummary* trace_summary) {}
-
-  /**
-   * Called upon entering the final marking pause. No more incremental marking
-   * steps will follow this call.
-   */
-  virtual void EnterFinalPause(EmbedderStackState stack_state) = 0;
-
-  /*
-   * Called by the embedder to request immediate finalization of the currently
-   * running tracing phase that has been started with TracePrologue and not
-   * yet finished with TraceEpilogue.
-   *
-   * Will be a noop when currently not in tracing.
-   *
-   * This is an experimental feature.
-   */
-  void FinalizeTracing();
-
-  /**
-   * See documentation on EmbedderRootsHandler.
-   */
-  virtual bool IsRootForNonTracingGC(
-      const v8::TracedReference<v8::Value>& handle);
-
-  /**
-   * See documentation on EmbedderRootsHandler.
-   */
-  virtual void ResetHandleInNonTracingGC(
-      const v8::TracedReference<v8::Value>& handle);
-
-  /*
-   * Called by the embedder to signal newly allocated or freed memory. Not bound
-   * to tracing phases. Embedders should trade off when increments are reported
-   * as V8 may consult global heuristics on whether to trigger garbage
-   * collection on this change.
-   */
-  void IncreaseAllocatedSize(size_t bytes);
-  void DecreaseAllocatedSize(size_t bytes);
-
-  /*
-   * Returns the v8::Isolate this tracer is attached too and |nullptr| if it
-   * is not attached to any v8::Isolate.
-   */
-  v8::Isolate* isolate() const { return v8_isolate_; }
-
- protected:
-  v8::Isolate* v8_isolate_ = nullptr;
-
-  friend class internal::LocalEmbedderHeapTracer;
-};
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_EMBEDDER_HEAP_H_

data/vendor/v8/include/v8-fast-api-calls.h

@@ -247,6 +247,7 @@ class CTypeInfo {
     kUint64,
     kFloat32,
     kFloat64,
+    kPointer,
     kV8Value,
     kSeqOneByteString,
     kApiObject,  // This will be deprecated once all users have
@@ -435,6 +436,7 @@ struct AnyCType {
     uint64_t uint64_value;
     float float_value;
     double double_value;
+    void* pointer_value;
     Local<Object> object_value;
     Local<Array> sequence_value;
     const FastApiTypedArray<uint8_t>* uint8_ta_value;
@@ -620,6 +622,7 @@ class CFunctionInfoImpl : public CFunctionInfo {
                       kReturnType == CTypeInfo::Type::kUint32 ||
                       kReturnType == CTypeInfo::Type::kFloat32 ||
                       kReturnType == CTypeInfo::Type::kFloat64 ||
+                      kReturnType == CTypeInfo::Type::kPointer ||
                       kReturnType == CTypeInfo::Type::kAny,
                   "64-bit int, string and api object values are not currently "
                   "supported return types.");
@@ -658,13 +661,14 @@ struct CTypeInfoTraits {};
 
 #define PRIMITIVE_C_TYPES(V) \
   V(bool, kBool)             \
+  V(uint8_t, kUint8)         \
   V(int32_t, kInt32)         \
   V(uint32_t, kUint32)       \
   V(int64_t, kInt64)         \
   V(uint64_t, kUint64)       \
   V(float, kFloat32)         \
   V(double, kFloat64)        \
-  V(uint8_t, kUint8)
+  V(void*, kPointer)
 
 // Same as above, but includes deprecated types for compatibility.
 #define ALL_C_TYPES(V)               \
@@ -698,13 +702,13 @@ PRIMITIVE_C_TYPES(DEFINE_TYPE_INFO_TRAITS)
   };
 
 #define TYPED_ARRAY_C_TYPES(V) \
+  V(uint8_t, kUint8)           \
   V(int32_t, kInt32)           \
   V(uint32_t, kUint32)         \
   V(int64_t, kInt64)           \
   V(uint64_t, kUint64)         \
   V(float, kFloat32)           \
-  V(double, kFloat64)          \
-  V(uint8_t, kUint8)
+  V(double, kFloat64)
 
 TYPED_ARRAY_C_TYPES(SPECIALIZE_GET_TYPE_INFO_HELPER_FOR_TA)