node-linux-s390x 22.9.0 → 23.0.0

package/include/node/v8-isolate.h

@@ -18,6 +18,7 @@
 #include "v8-data.h"               // NOLINT(build/include_directory)
 #include "v8-debug.h"              // NOLINT(build/include_directory)
 #include "v8-embedder-heap.h"      // NOLINT(build/include_directory)
+#include "v8-exception.h"          // NOLINT(build/include_directory)
 #include "v8-function-callback.h"  // NOLINT(build/include_directory)
 #include "v8-internal.h"           // NOLINT(build/include_directory)
 #include "v8-local-handle.h"       // NOLINT(build/include_directory)
@@ -277,11 +278,6 @@ class V8_EXPORT Isolate {
      */
     bool allow_atomics_wait = true;
 
-    /**
-     * Termination is postponed when there is no active SafeForTerminationScope.
-     */
-    bool only_terminate_in_safe_scope = false;
-
     /**
      * The following parameters describe the offsets for addressing type info
      * for wrapped API objects and are used by the fast C API
@@ -390,21 +386,6 @@ class V8_EXPORT Isolate {
     friend class internal::ThreadLocalTop;
   };
 
-  /**
-   * This scope allows terminations inside direct V8 API calls and forbid them
-   * inside any recursive API calls without explicit SafeForTerminationScope.
-   */
-  class V8_EXPORT V8_NODISCARD SafeForTerminationScope {
-   public:
-    V8_DEPRECATE_SOON("All code should be safe for termination")
-    explicit SafeForTerminationScope(v8::Isolate* v8_isolate) {}
-    ~SafeForTerminationScope() {}
-
-    // Prevent copying of Scope objects.
-    SafeForTerminationScope(const SafeForTerminationScope&) = delete;
-    SafeForTerminationScope& operator=(const SafeForTerminationScope&) = delete;
-  };
-
   /**
    * Types of garbage collections that can be requested via
    * RequestGarbageCollectionForTesting.
@@ -564,6 +545,9 @@ class V8_EXPORT Isolate {
     kWasmExnRef = 138,
     kWasmTypedFuncRef = 139,
     kInvalidatedStringWrapperToPrimitiveProtector = 140,
+    kDocumentAllLegacyCall = 141,
+    kDocumentAllLegacyConstruct = 142,
+    kConsoleContext = 143,
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
@@ -581,6 +565,21 @@ class V8_EXPORT Isolate {
                   kMessageWarning,
   };
 
+  // The different priorities that an isolate can have.
+  enum class Priority {
+    // The isolate does not relate to content that is currently important
+    // to the user. Lowest priority.
+    kBestEffort,
+
+    // The isolate contributes to content that is visible to the user, like a
+    // visible iframe that's not interacted directly with. High priority.
+    kUserVisible,
+
+    // The isolate contributes to content that is of the utmost importance to
+    // the user, like visible content in the focused window. Highest priority.
+    kUserBlocking,
+  };
+
   using UseCounterCallback = void (*)(Isolate* isolate,
                                       UseCounterFeature feature);
 
@@ -692,6 +691,11 @@ class V8_EXPORT Isolate {
    */
   void SetPrepareStackTraceCallback(PrepareStackTraceCallback callback);
 
+  /**
+   * Get the stackTraceLimit property of Error.
+   */
+  int GetStackTraceLimit();
+
 #if defined(V8_OS_WIN)
   /**
    * This specifies the callback called when an ETW tracing session starts.
@@ -933,6 +937,12 @@ class V8_EXPORT Isolate {
    */
   Local<Context> GetIncumbentContext();
 
+  /**
+   * Returns the host defined options set for currently running script or
+   * module, if available.
+   */
+  MaybeLocal<Data> GetCurrentHostDefinedOptions();
+
   /**
    * Schedules a v8::Exception::Error with the given message.
    * See ThrowException for more details. Templatized to provide compile-time
@@ -1274,6 +1284,15 @@ class V8_EXPORT Isolate {
    */
   void SetPromiseRejectCallback(PromiseRejectCallback callback);
 
+  /**
+   * This is a part of experimental Api and might be changed without further
+   * notice.
+   * Do not use it.
+   *
+   * Set callback to notify about a new exception being thrown.
+   */
+  void SetExceptionPropagationCallback(ExceptionPropagationCallback callback);
+
   /**
    * Runs the default MicrotaskQueue until it gets empty and perform other
    * microtask checkpoint steps, such as calling ClearKeptObjects. Asserts that
@@ -1363,24 +1382,6 @@ class V8_EXPORT Isolate {
    */
   void SetAddCrashKeyCallback(AddCrashKeyCallback);
 
-  /**
-   * Optional notification that the embedder is idle.
-   * V8 uses the notification to perform garbage collection.
-   * This call can be used repeatedly if the embedder remains idle.
-   * Returns true if the embedder should stop calling IdleNotificationDeadline
-   * until real work has been done.  This indicates that V8 has done
-   * as much cleanup as it will be able to do.
-   *
-   * The deadline_in_seconds argument specifies the deadline V8 has to finish
-   * garbage collection work. deadline_in_seconds is compared with
-   * MonotonicallyIncreasingTime() and should be based on the same timebase as
-   * that function. There is no guarantee that the actual work will be done
-   * within the time limit.
-   */
-  V8_DEPRECATE_SOON(
-      "Use MemoryPressureNotification() to influence the GC schedule.")
-  bool IdleNotificationDeadline(double deadline_in_seconds);
-
   /**
    * Optional notification that the system is running low on memory.
    * V8 uses these notifications to attempt to free memory.
@@ -1402,14 +1403,22 @@ class V8_EXPORT Isolate {
    * Optional notification that the isolate switched to the foreground.
    * V8 uses these notifications to guide heuristics.
    */
+  V8_DEPRECATE_SOON("Use SetPriority(Priority::kUserBlocking) instead")
   void IsolateInForegroundNotification();
 
   /**
    * Optional notification that the isolate switched to the background.
    * V8 uses these notifications to guide heuristics.
    */
+  V8_DEPRECATE_SOON("Use SetPriority(Priority::kBestEffort) instead")
   void IsolateInBackgroundNotification();
 
+  /**
+   * Optional notification that the isolate changed `priority`.
+   * V8 uses the priority value to guide heuristics.
+   */
+  void SetPriority(Priority priority);
+
   /**
    * Optional notification to tell V8 the current performance requirements
    * of the embedder based on RAIL.
@@ -1593,6 +1602,9 @@ class V8_EXPORT Isolate {
    * Register callback to control whether compile hints magic comments are
    * enabled.
    */
+  V8_DEPRECATED(
+      "Will be removed, use ScriptCompiler::CompileOptions for enabling the "
+      "compile hints magic comments")
   void SetJavaScriptCompileHintsMagicEnabledCallback(
       JavaScriptCompileHintsMagicEnabledCallback callback);
 
@@ -1657,7 +1669,7 @@ class V8_EXPORT Isolate {
    * heap.  GC is not invoked prior to iterating, therefore there is no
    * guarantee that visited objects are still alive.
    */
-  V8_DEPRECATE_SOON("Will be removed without replacement. crbug.com/v8/14172")
+  V8_DEPRECATED("Will be removed without replacement. crbug.com/v8/14172")
   void VisitExternalResources(ExternalResourceVisitor* visitor);
 
   /**

package/include/node/v8-local-handle.h

@@ -51,8 +51,6 @@ class Isolate;
 class Object;
 template <class F1, class F2, class F3>
 class PersistentValueMapBase;
-template <class F1, class F2>
-class PersistentValueVector;
 class Primitive;
 class Private;
 template <class F>
@@ -152,11 +150,11 @@ class V8_EXPORT V8_NODISCARD HandleScope {
 
 /**
  * A base class for local handles.
- * Its implementation depends on whether direct local support is enabled.
+ * Its implementation depends on whether direct handle support is enabled.
  * When it is, a local handle contains a direct pointer to the referenced
  * object, otherwise it contains an indirect pointer.
  */
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
 
 template <typename T>
 class LocalBase : public api_internal::DirectHandleBase {
@@ -185,7 +183,7 @@ class LocalBase : public api_internal::DirectHandleBase {
   }
 };
 
-#else  // !V8_ENABLE_DIRECT_LOCAL
+#else  // !V8_ENABLE_DIRECT_HANDLE
 
 template <typename T>
 class LocalBase : public api_internal::IndirectHandleBase {
@@ -217,7 +215,7 @@ class LocalBase : public api_internal::IndirectHandleBase {
   }
 };
 
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 
 /**
  * An object reference managed by the v8 garbage collector.
@@ -382,8 +380,6 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
   friend class InternalEscapableScope;
   template <class F1, class F2, class F3>
   friend class PersistentValueMapBase;
-  template <class F1, class F2>
-  friend class PersistentValueVector;
   template <class F>
   friend class ReturnValue;
   template <class F>
@@ -404,13 +400,13 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
     return Local<T>(LocalBase<T>::FromSlot(slot));
   }
 
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
   friend class TypecheckWitness;
 
   V8_INLINE static Local<T> FromAddress(internal::Address ptr) {
     return Local<T>(LocalBase<T>(ptr));
   }
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 
   V8_INLINE static Local<T> New(Isolate* isolate, internal::Address value) {
     return Local<T>(LocalBase<T>::New(isolate, value));
@@ -439,16 +435,16 @@ class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> {
   // In this case, the check is also enforced in the copy constructor and we
   // need to suppress it.
   LocalUnchecked(const LocalUnchecked& other)
-      : Local<T>(other, Local<T>::do_not_check) {}
-  LocalUnchecked& operator=(const LocalUnchecked&) = default;
+      : Local<T>(other, Local<T>::do_not_check) noexcept {}
+  LocalUnchecked& operator=(const LocalUnchecked&) noexcept = default;
 #endif
 
   // Implicit conversion from Local.
-  LocalUnchecked(const Local<T>& other)  // NOLINT(runtime/explicit)
+  LocalUnchecked(const Local<T>& other) noexcept  // NOLINT(runtime/explicit)
       : Local<T>(other, Local<T>::do_not_check) {}
 };
 
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
 // Off-stack allocated direct locals must be registered as strong roots.
 // For off-stack indirect locals, this is not necessary.
 
@@ -460,8 +456,10 @@ class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
   static_assert(sizeof(value_type) == sizeof(Address));
 
   explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {}
-  explicit StrongRootAllocator(v8::Isolate* isolate)
+  explicit StrongRootAllocator(Isolate* isolate)
       : StrongRootAllocatorBase(isolate) {}
+  explicit StrongRootAllocator(v8::Isolate* isolate)
+      : StrongRootAllocatorBase(reinterpret_cast<Isolate*>(isolate)) {}
   template <typename U>
   StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept
       : StrongRootAllocatorBase(other) {}
@@ -473,7 +471,7 @@ class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
     return deallocate_impl(reinterpret_cast<Address*>(p), n);
   }
 };
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 }  // namespace internal
 
 template <typename T>
@@ -481,7 +479,7 @@ class LocalVector {
  private:
   using element_type = internal::LocalUnchecked<T>;
 
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
   using allocator_type = internal::StrongRootAllocator<element_type>;
 
   static allocator_type make_allocator(Isolate* isolate) noexcept {
@@ -493,7 +491,7 @@ class LocalVector {
   static allocator_type make_allocator(Isolate* isolate) noexcept {
     return allocator_type();
   }
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 
   using vector_type = std::vector<element_type, allocator_type>;
 
@@ -560,6 +558,7 @@ class LocalVector {
 
   LocalVector<T>& operator=(std::initializer_list<Local<T>> init) {
     backing_.clear();
+    backing_.reserve(init.size());
     backing_.insert(backing_.end(), init.begin(), init.end());
     return *this;
   }
@@ -716,7 +715,7 @@ class V8_EXPORT V8_NODISCARD EscapableHandleScope
   V8_INLINE ~EscapableHandleScope() = default;
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
     return value;
 #else
     if (value.IsEmpty()) return value;

package/include/node/v8-message.h

@@ -61,27 +61,6 @@ class ScriptOriginOptions {
  */
 class V8_EXPORT ScriptOrigin {
  public:
-  V8_DEPRECATE_SOON("Use constructor without the isolate.")
-  V8_INLINE ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
-                         int resource_line_offset = 0,
-                         int resource_column_offset = 0,
-                         bool resource_is_shared_cross_origin = false,
-                         int script_id = -1,
-                         Local<Value> source_map_url = Local<Value>(),
-                         bool resource_is_opaque = false, bool is_wasm = false,
-                         bool is_module = false,
-                         Local<Data> host_defined_options = Local<Data>())
-      : resource_name_(resource_name),
-        resource_line_offset_(resource_line_offset),
-        resource_column_offset_(resource_column_offset),
-        options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
-                 is_module),
-        script_id_(script_id),
-        source_map_url_(source_map_url),
-        host_defined_options_(host_defined_options) {
-    VerifyHostDefinedOptions();
-  }
-
   V8_INLINE ScriptOrigin(Local<Value> resource_name,
                          int resource_line_offset = 0,
                          int resource_column_offset = 0,

package/include/node/v8-microtask-queue.h

@@ -118,11 +118,6 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
  public:
   enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
 
-  V8_DEPRECATE_SOON(
-      "May be incorrect if context was created with non-default microtask "
-      "queue")
-  MicrotasksScope(Isolate* isolate, Type type);
-
   MicrotasksScope(Local<Context> context, Type type);
   MicrotasksScope(Isolate* isolate, MicrotaskQueue* microtask_queue, Type type);
   ~MicrotasksScope();