node-linux-arm64 22.10.0 → 23.1.0

package/include/node/v8-context.h

@@ -107,6 +107,10 @@ class V8_EXPORT Context : public Data {
    * configured if the default context snapshot contains no pointer embedder
    * data, or if no custom startup snapshot is configured in the
    * v8::CreateParams used to create the isolate.
+   *
+   * \param api_wrapper_deserializer An optional callback used to deserialize
+   * API wrapper objects that was initially set with v8::Object::Wrap() and then
+   * serialized using SerializeAPIWrapperCallback.
    */
   static Local<Context> New(
       Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
@@ -116,17 +120,19 @@ class V8_EXPORT Context : public Data {
           DeserializeInternalFieldsCallback(),
       MicrotaskQueue* microtask_queue = nullptr,
       DeserializeContextDataCallback context_data_deserializer =
-          DeserializeContextDataCallback());
+          DeserializeContextDataCallback(),
+      DeserializeAPIWrapperCallback api_wrapper_deserializer =
+          DeserializeAPIWrapperCallback());
 
   /**
    * Create a new context from a (non-default) context snapshot. There
    * is no way to provide a global object template since we do not create
    * a new global object from template, but we can reuse a global object.
    *
-   * \param isolate See v8::Context::New.
+   * \param isolate See v8::Context::New().
    *
    * \param context_snapshot_index The index of the context snapshot to
-   * deserialize from. Use v8::Context::New for the default snapshot.
+   * deserialize from. Use v8::Context::New() for the default snapshot.
    *
    * \param internal_fields_deserializer An optional callback used
    * to deserialize fields set by
@@ -136,19 +142,23 @@ class V8_EXPORT Context : public Data {
    * pointer fields in the default context snapshot or if no startup
    * snapshot is configured when the isolate is created.
    *
-   * \param extensions See v8::Context::New.
+   * \param extensions See v8::Context::New().
    *
-   * \param global_object See v8::Context::New.
+   * \param global_object See v8::Context::New().
    *
    * \param internal_fields_deserializer Similar to
-   * internal_fields_deserializer in v8::Context::New but applies to
+   * internal_fields_deserializer in v8::Context::New() but applies to
    * the context specified by the context_snapshot_index.
    *
-   * \param microtask_queue  See v8::Context::New.
+   * \param microtask_queue  See v8::Context::New().
    *
    * \param context_data_deserializer  Similar to
-   * context_data_deserializer in v8::Context::New but applies to
+   * context_data_deserializer in v8::Context::New() but applies to
    * the context specified by the context_snapshot_index.
+   *
+   *\param api_wrapper_deserializer Similar to api_wrapper_deserializer in
+   * v8::Context::New() but applies to the context specified by the
+   * context_snapshot_index.
    */
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
@@ -158,7 +168,9 @@ class V8_EXPORT Context : public Data {
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
       MicrotaskQueue* microtask_queue = nullptr,
       DeserializeContextDataCallback context_data_deserializer =
-          DeserializeContextDataCallback());
+          DeserializeContextDataCallback(),
+      DeserializeAPIWrapperCallback api_wrapper_deserializer =
+          DeserializeAPIWrapperCallback());
 
   /**
    * Returns an global object that isn't backed by an actual context.
@@ -290,6 +302,8 @@ class V8_EXPORT Context : public Data {
    * SetAlignedPointerInEmbedderData with the same index. Note that index 0
    * currently has a special meaning for Chrome's debugger.
    */
+  V8_INLINE void* GetAlignedPointerFromEmbedderData(Isolate* isolate,
+                                                    int index);
   V8_INLINE void* GetAlignedPointerFromEmbedderData(int index);
 
   /**
@@ -444,6 +458,24 @@ Local<Value> Context::GetEmbedderData(int index) {
 #endif
 }
 
+void* Context::GetAlignedPointerFromEmbedderData(Isolate* isolate, int index) {
+#if !defined(V8_ENABLE_CHECKS)
+  using A = internal::Address;
+  using I = internal::Internals;
+  A ctx = internal::ValueHelper::ValueAsAddress(this);
+  A embedder_data =
+      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
+  int value_offset = I::kEmbedderDataArrayHeaderSize +
+                     (I::kEmbedderDataSlotSize * index) +
+                     I::kEmbedderDataSlotExternalPointerOffset;
+  return reinterpret_cast<void*>(
+      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+          isolate, embedder_data, value_offset));
+#else
+  return SlowGetAlignedPointerFromEmbedderData(index);
+#endif
+}
+
 void* Context::GetAlignedPointerFromEmbedderData(int index) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;

package/include/node/v8-cppgc.h

@@ -32,62 +32,15 @@ class CppHeap;
 
 class CustomSpaceStatisticsReceiver;
 
-/**
- * Describes how V8 wrapper objects maintain references to garbage-collected C++
- * objects.
- */
-struct WrapperDescriptor final {
-  /**
-   * The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and
-   * related APIs to add additional data to an object which is used to identify
-   * JS->C++ references.
-   */
-  using InternalFieldIndex = int;
-
-  /**
-   * Unknown embedder id. The value is reserved for internal usages and must not
-   * be used with `CppHeap`.
-   */
-  static constexpr uint16_t kUnknownEmbedderId = UINT16_MAX;
-
-  constexpr WrapperDescriptor(InternalFieldIndex wrappable_type_index,
-                              InternalFieldIndex wrappable_instance_index,
-                              uint16_t embedder_id_for_garbage_collected)
-      : wrappable_type_index(wrappable_type_index),
-        wrappable_instance_index(wrappable_instance_index),
-        embedder_id_for_garbage_collected(embedder_id_for_garbage_collected) {}
-
-  /**
-   * Index of the wrappable type.
-   */
-  InternalFieldIndex wrappable_type_index;
-
-  /**
-   * Index of the wrappable instance.
-   */
-  InternalFieldIndex wrappable_instance_index;
-
-  /**
-   * Embedder id identifying instances of garbage-collected objects. It is
-   * expected that the first field of the wrappable type is a uint16_t holding
-   * the id. Only references to instances of wrappables types with an id of
-   * `embedder_id_for_garbage_collected` will be considered by CppHeap.
-   */
-  uint16_t embedder_id_for_garbage_collected;
-};
-
 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) {}
+  explicit CppHeapCreateParams(
+      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces)
+      : custom_spaces(std::move(custom_spaces)) {}
 
   CppHeapCreateParams(const CppHeapCreateParams&) = delete;
   CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;
 
   std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
-  WrapperDescriptor wrapper_descriptor;
   /**
    * Specifies which kind of marking are supported by the heap. The type may be
    * further reduced via runtime flags when attaching the heap to an Isolate.
@@ -177,11 +130,6 @@ 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;
 

package/include/node/v8-date.h

@@ -21,6 +21,10 @@ class V8_EXPORT Date : public Object {
   static V8_WARN_UNUSED_RESULT MaybeLocal<Value> New(Local<Context> context,
                                                      double time);
 
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse(
+      Local<Context> context,
+      Local<String> date_string);
+
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
@@ -32,6 +36,11 @@ class V8_EXPORT Date : public Object {
    */
   v8::Local<v8::String> ToISOString() const;
 
+  /**
+   * Generates UTC string representation.
+   */
+  v8::Local<v8::String> ToUTCString() const;
+
   V8_INLINE static Date* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);

package/include/node/v8-embedder-heap.h

@@ -29,6 +29,8 @@ class V8_EXPORT EmbedderRootsHandler {
   virtual ~EmbedderRootsHandler() = default;
 
   EmbedderRootsHandler() = default;
+
+  V8_DEPRECATED("Use the default constructor instead.")
   explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling)
       : default_traced_reference_handling_(default_traced_reference_handling) {}
 
@@ -47,6 +49,7 @@ class V8_EXPORT EmbedderRootsHandler {
    *
    * The concrete implementations must be thread-safe.
    */
+  V8_DEPRECATED("Use TracedReferenceHandling::kDroppable instead.")
   virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 
   /**
@@ -72,7 +75,7 @@ class V8_EXPORT EmbedderRootsHandler {
 
  private:
   const RootHandling default_traced_reference_handling_ =
-      RootHandling::kQueryEmbedderForNonDroppableReferences;
+      RootHandling::kDontQueryEmbedderForAnyReference;
 
   friend class internal::TracedHandles;
 };

package/include/node/v8-exception.h

@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -58,8 +59,77 @@ class V8_EXPORT Exception {
    * of a given exception, or an empty handle if not available.
    */
   static Local<StackTrace> GetStackTrace(Local<Value> exception);
+
+  /**
+   * Captures the current stack trace and attaches it to the given object in the
+   * form of `stack` property.
+   */
+  static Maybe<bool> CaptureStackTrace(Local<Context> context,
+                                       Local<Object> object);
 };
 
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+enum class ExceptionContext : uint32_t {
+  kUnknown,
+  kConstructor,
+  kOperation,
+  kAttributeGet,
+  kAttributeSet,
+  kIndexedQuery,
+  kIndexedGetter,
+  kIndexedDescriptor,
+  kIndexedSetter,
+  kIndexedDefiner,
+  kIndexedDeleter,
+  kNamedQuery,
+  kNamedGetter,
+  kNamedDescriptor,
+  kNamedSetter,
+  kNamedDefiner,
+  kNamedDeleter,
+  kNamedEnumerator
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+class ExceptionPropagationMessage {
+ public:
+  ExceptionPropagationMessage(v8::Isolate* isolate, Local<Object> exception,
+                              Local<String> interface_name,
+                              Local<String> property_name,
+                              ExceptionContext exception_context)
+      : isolate_(isolate),
+        exception_(exception),
+        interface_name_(interface_name),
+        property_name_(property_name),
+        exception_context_(exception_context) {}
+
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE Local<Object> GetException() const { return exception_; }
+  V8_INLINE Local<String> GetInterfaceName() const { return interface_name_; }
+  V8_INLINE Local<String> GetPropertyName() const { return property_name_; }
+  V8_INLINE ExceptionContext GetExceptionContext() const {
+    return exception_context_;
+  }
+
+ private:
+  Isolate* isolate_;
+  Local<Object> exception_;
+  Local<String> interface_name_;
+  Local<String> property_name_;
+  ExceptionContext exception_context_;
+};
+
+using ExceptionPropagationCallback =
+    void (*)(ExceptionPropagationMessage message);
+
 /**
  * An external exception handler.
  */