src: add a variant of ToV8Value() for primitive arrays

Adds a variant of ToV8Value for array of primitives that
do not need to throw during conversion - there is essentially
no exceptions that can be thrown then an array
of integers is created.

PR-URL: #57576
Reviewed-By: Yagiz Nizipli <[email protected]>
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Joyee Cheung <[email protected]>

Author: Aditi-1400

src/node_v8.cc

@@ -385,23 +385,13 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
         FIXED_ONE_BYTE_STRING(isolate, "bucket_size"),
         FIXED_ONE_BYTE_STRING(isolate, "free_count"),
         FIXED_ONE_BYTE_STRING(isolate, "free_size")};
-    Local<Value> bucket_size_value;
-    if (!ToV8Value(context, space_stats.free_list_stats.bucket_size)
-             .ToLocal(&bucket_size_value)) {
-      return MaybeLocal<Object>();
-    }
-    Local<Value> free_count_value;
-    if (!ToV8Value(context, space_stats.free_list_stats.free_count)
-             .ToLocal(&free_count_value)) {
-      return MaybeLocal<Object>();
-    }
-    Local<Value> free_size_value;
-    if (!ToV8Value(context, space_stats.free_list_stats.free_size)
-             .ToLocal(&free_size_value)) {
-      return MaybeLocal<Object>();
-    }
     Local<Value> free_list_statistics_values[] = {
-        bucket_size_value, free_count_value, free_size_value};
+        ToV8ValuePrimitiveArray(
+            context, space_stats.free_list_stats.bucket_size, isolate),
+        ToV8ValuePrimitiveArray(
+            context, space_stats.free_list_stats.free_count, isolate),
+        ToV8ValuePrimitiveArray(
+            context, space_stats.free_list_stats.free_size, isolate)};
 
     Local<Object> free_list_statistics_obj =
         Object::New(isolate,

src/util-inl.h

@@ -428,12 +428,9 @@ v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
   return handle_scope.Escape(ret);
 }
 
-template <typename T, typename >
-v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
-                                    const T& number,
-                                    v8::Isolate* isolate) {
-  if (isolate == nullptr) isolate = context->GetIsolate();
-
+template <typename T>
+v8::Local<v8::Value> ConvertNumberToV8Value(v8::Isolate* isolate,
+                                            const T& number) {
   using Limits = std::numeric_limits<T>;
   // Choose Uint32, Int32, or Double depending on range checks.
   // These checks should all collapse at compile time.
@@ -454,6 +451,43 @@ v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
   return v8::Number::New(isolate, static_cast<double>(number));
 }
 
+template <typename T, typename>
+v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
+                                    const T& number,
+                                    v8::Isolate* isolate) {
+  if (isolate == nullptr) isolate = context->GetIsolate();
+  return ConvertNumberToV8Value(isolate, number);
+}
+
+template <typename T>
+v8::Local<v8::Array> ToV8ValuePrimitiveArray(v8::Local<v8::Context> context,
+                                             const std::vector<T>& vec,
+                                             v8::Isolate* isolate) {
+  static_assert(
+      std::is_same_v<T, bool> || std::is_integral_v<T> ||
+          std::is_floating_point_v<T>,
+      "Only primitive types (bool, integral, floating-point) are supported.");
+
+  if (isolate == nullptr) isolate = context->GetIsolate();
+  v8::EscapableHandleScope handle_scope(isolate);
+
+  v8::LocalVector<v8::Value> elements(isolate);
+  elements.reserve(vec.size());
+
+  for (const auto& value : vec) {
+    if constexpr (std::is_same_v<T, bool>) {
+      elements.emplace_back(v8::Boolean::New(isolate, value));
+    } else {
+      v8::Local<v8::Value> v = ConvertNumberToV8Value(isolate, value);
+      elements.emplace_back(v);
+    }
+  }
+
+  v8::Local<v8::Array> arr =
+      v8::Array::New(isolate, elements.data(), elements.size());
+  return handle_scope.Escape(arr);
+}
+
 SlicedArguments::SlicedArguments(
     const v8::FunctionCallbackInfo<v8::Value>& args, size_t start) {
   const size_t length = static_cast<size_t>(args.Length());