src: fixup lint issues after dictionary template change

Author: jasnell

src/node_sqlite.cc

@@ -124,7 +124,7 @@ namespace {
 Local<DictionaryTemplate> getLazyIterTemplate(Environment* env) {
  auto iter_template = env->iter_template();
  if (iter_template.IsEmpty()) {
- std::string_view iter_keys[] = {"done", "value"};
+ static constexpr std::string_view iter_keys[] = {"done", "value"};
  iter_template = DictionaryTemplate::New(env->isolate(), iter_keys);
  env->set_iter_template(iter_template);
  }
@@ -2254,12 +2254,11 @@ void StatementSync::Columns(const FunctionCallbackInfo<Value>& args) {
  LocalVector<Value> cols(isolate);
  auto sqlite_column_template = env->sqlite_column_template();
  if (sqlite_column_template.IsEmpty()) {
- std::string_view col_keys[] = {
+ static constexpr std::string_view col_keys[] = {
  "column", "database", "name", "table", "type"};
  sqlite_column_template = DictionaryTemplate::New(isolate, col_keys);
  env->set_sqlite_column_template(sqlite_column_template);
  }
- Local<Value> value;
 
  cols.reserve(num_cols);
  for (int i = 0; i < num_cols; ++i) {
@@ -2275,8 +2274,12 @@ void StatementSync::Columns(const FunctionCallbackInfo<Value>& args) {
  isolate, sqlite3_column_decltype(stmt->statement_, i)),
  };
 
- cols.emplace_back(
- sqlite_column_template->NewInstance(env->context(), values));
+ Local<Object> col;
+ if (!NewDictionaryInstance(env->context(), sqlite_column_template, values)
+ .ToLocal(&col)) {
+ return;
+ }
+ cols.emplace_back(col);
  }
 
  args.GetReturnValue().Set(Array::New(isolate, cols.data(), cols.size()));
@@ -2516,8 +2519,11 @@ void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
  Boolean::New(isolate, true),
  Null(isolate),
  };
- args.GetReturnValue().Set(
- iter_template->NewInstance(env->context(), values));
+ Local<Object> result;
+ if (NewDictionaryInstance(env->context(), iter_template, values)
+ .ToLocal(&result)) {
+ args.GetReturnValue().Set(result);
+ }
  return;
  }
 
@@ -2527,8 +2533,11 @@ void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
  env->isolate(), iter->stmt_->db_.get(), r, SQLITE_DONE, void());
  sqlite3_reset(iter->stmt_->statement_);
  MaybeLocal<Value> values[] = {Boolean::New(isolate, true), Null(isolate)};
- args.GetReturnValue().Set(
- iter_template->NewInstance(env->context(), values));
+ Local<Object> result;
+ if (NewDictionaryInstance(env->context(), iter_template, values)
+ .ToLocal(&result)) {
+ args.GetReturnValue().Set(result);
+ }
  return;
  }
 
@@ -2557,7 +2566,11 @@ void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
  }
 
  MaybeLocal<Value> values[] = {Boolean::New(isolate, false), row_value};
- args.GetReturnValue().Set(iter_template->NewInstance(env->context(), values));
+ Local<Object> result;
+ if (NewDictionaryInstance(env->context(), iter_template, values)
+ .ToLocal(&result)) {
+ args.GetReturnValue().Set(result);
+ }
 }
 
 void StatementSyncIterator::Return(const FunctionCallbackInfo<Value>& args) {
@@ -2574,8 +2587,11 @@ void StatementSyncIterator::Return(const FunctionCallbackInfo<Value>& args) {
  auto iter_template = getLazyIterTemplate(env);
  MaybeLocal<Value> values[] = {Boolean::New(isolate, true), Null(isolate)};
 
- Local<Object> result = iter_template->NewInstance(env->context(), values);
- args.GetReturnValue().Set(result);
+ Local<Object> result;
+ if (NewDictionaryInstance(env->context(), iter_template, values)
+ .ToLocal(&result)) {
+ args.GetReturnValue().Set(result);
+ }
 }
 
 Session::Session(Environment* env,

src/node_url_pattern.cc

@@ -61,7 +61,6 @@ using v8::FunctionTemplate;
 using v8::Global;
 using v8::Isolate;
 using v8::Local;
-using v8::LocalVector;
 using v8::MaybeLocal;
 using v8::Name;
 using v8::NewStringType;
@@ -400,7 +399,7 @@ MaybeLocal<Value> URLPattern::URLPatternResult::ToJSValue(
 
  auto tmpl = env->urlpatternresult_template();
  if (tmpl.IsEmpty()) {
- std::string_view namesVec[] = {
+ static constexpr std::string_view namesVec[] = {
  "inputs",
  "protocol",
  "username",
@@ -416,10 +415,8 @@ MaybeLocal<Value> URLPattern::URLPatternResult::ToJSValue(
  }
 
  size_t index = 0;
- auto context = isolate->GetCurrentContext();
-
  MaybeLocal<Value> vals[] = {
- Array::New(context,
+ Array::New(env->context(),
  result.inputs.size(),
  [&index, &inputs = result.inputs, env]() {
  auto& input = inputs[index++];
@@ -440,9 +437,8 @@ MaybeLocal<Value> URLPattern::URLPatternResult::ToJSValue(
  URLPatternComponentResult::ToJSObject(env, result.port),
  URLPatternComponentResult::ToJSObject(env, result.pathname),
  URLPatternComponentResult::ToJSObject(env, result.search),
- URLPatternComponentResult::ToJSObject(env, result.hash),
- };
- return tmpl->NewInstance(env->context(), vals);
+ URLPatternComponentResult::ToJSObject(env, result.hash)};
+ return NewDictionaryInstance(env->context(), tmpl, vals);
 }
 
 std::optional<ada::url_pattern_options>

src/node_util.cc

@@ -267,13 +267,14 @@ static void GetCallSites(const FunctionCallbackInfo<Value>& args) {
 
  auto callsite_template = env->callsite_template();
  if (callsite_template.IsEmpty()) {
- std::string_view names[] = {"functionName",
- "scriptId",
- "scriptName",
- "lineNumber",
- "columnNumber",
- // TODO(legendecas): deprecate CallSite.column.
- "column"};
+ static constexpr std::string_view names[] = {
+ "functionName",
+ "scriptId",
+ "scriptName",
+ "lineNumber",
+ "columnNumber",
+ // TODO(legendecas): deprecate CallSite.column.
+ "column"};
  callsite_template = DictionaryTemplate::New(isolate, names);
  env->set_callsite_template(callsite_template);
  }
@@ -304,8 +305,12 @@ static void GetCallSites(const FunctionCallbackInfo<Value>& args) {
  Integer::NewFromUnsigned(isolate, stack_frame->GetColumn()),
  };
 
- callsite_objects.push_back(
- callsite_template->NewInstance(env->context(), values));
+ Local<Object> callsite;
+ if (!NewDictionaryInstance(env->context(), callsite_template, values)
+ .ToLocal(&callsite)) {
+ return;
+ }
+ callsite_objects.push_back(callsite);
  }
 
  Local<Array> callsites =

src/node_v8.cc

@@ -47,7 +47,6 @@ using v8::Isolate;
 using v8::Local;
 using v8::LocalVector;
 using v8::MaybeLocal;
-using v8::Name;
 using v8::Object;
 using v8::ScriptCompiler;
 using v8::String;
@@ -338,16 +337,18 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  auto space_stats_tmpl = env->space_stats_template();
  auto heap_stats_tmpl = env->v8_heap_statistics_template();
  if (object_stats_template.IsEmpty()) {
- std::string_view object_stats_names[] = {"allocated_bytes", "object_count"};
+ static constexpr std::string_view object_stats_names[] = {"allocated_bytes",
+ "object_count"};
  object_stats_template =
  DictionaryTemplate::New(isolate, object_stats_names);
  env->set_object_stats_template(object_stats_template);
  }
  if (page_stats_tmpl.IsEmpty()) {
- std::string_view page_stats_names[] = {"committed_size_bytes",
- "resident_size_bytes",
- "used_size_bytes",
- "object_statistics"};
+ static constexpr std::string_view page_stats_names[] = {
+ "committed_size_bytes",
+ "resident_size_bytes",
+ "used_size_bytes",
+ "object_statistics"};
  page_stats_tmpl = DictionaryTemplate::New(isolate, page_stats_names);
  env->set_page_stats_template(page_stats_tmpl);
  }
@@ -359,21 +360,23 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  env->set_free_list_statistics_template(free_list_statistics_template);
  }
  if (space_stats_tmpl.IsEmpty()) {
- std::string_view space_stats_names[] = {"name",
- "committed_size_bytes",
- "resident_size_bytes",
- "used_size_bytes",
- "page_stats",
- "free_list_stats"};
+ static constexpr std::string_view space_stats_names[] = {
+ "name",
+ "committed_size_bytes",
+ "resident_size_bytes",
+ "used_size_bytes",
+ "page_stats",
+ "free_list_stats"};
  space_stats_tmpl = DictionaryTemplate::New(isolate, space_stats_names);
  env->set_space_stats_template(space_stats_tmpl);
  }
  if (heap_stats_tmpl.IsEmpty()) {
- std::string_view heap_statistics_names[] = {"committed_size_bytes",
- "resident_size_bytes",
- "used_size_bytes",
- "space_statistics",
- "type_names"};
+ static constexpr std::string_view heap_statistics_names[] = {
+ "committed_size_bytes",
+ "resident_size_bytes",
+ "used_size_bytes",
+ "space_statistics",
+ "type_names"};
  heap_stats_tmpl = DictionaryTemplate::New(isolate, heap_statistics_names);
  env->set_v8_heap_statistics_template(heap_stats_tmpl);
  }
@@ -398,8 +401,12 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  isolate, static_cast<uint32_t>(object_stats.allocated_bytes)),
  Uint32::NewFromUnsigned(
  isolate, static_cast<uint32_t>(object_stats.object_count))};
- Local<Object> object_stats_object =
- object_stats_template->NewInstance(context, object_stats_values);
+ Local<Object> object_stats_object;
+ if (!NewDictionaryInstance(
+ context, object_stats_template, object_stats_values)
+ .ToLocal(&object_stats_object)) {
+ return MaybeLocal<Object>();
+ }
  object_statistics_array.emplace_back(object_stats_object);
  }
 
@@ -414,8 +421,12 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  Array::New(isolate,
  object_statistics_array.data(),
  object_statistics_array.size())};
- page_statistics_array.emplace_back(
- page_stats_tmpl->NewInstance(context, page_stats_values));
+ Local<Object> page_stats_object;
+ if (!NewDictionaryInstance(context, page_stats_tmpl, page_stats_values)
+ .ToLocal(&page_stats_object)) {
+ return MaybeLocal<Object>();
+ }
+ page_statistics_array.emplace_back(page_stats_object);
  }
 
  // Free List Statistics
@@ -427,9 +438,13 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  ToV8ValuePrimitiveArray(
  context, space_stats.free_list_stats.free_size, isolate)};
 
- Local<Object> free_list_statistics_obj =
- free_list_statistics_template->NewInstance(context,
- free_list_statistics_values);
+ Local<Object> free_list_statistics_obj;
+ if (!NewDictionaryInstance(context,
+ free_list_statistics_template,
+ free_list_statistics_values)
+ .ToLocal(&free_list_statistics_obj)) {
+ return MaybeLocal<Object>();
+ }
 
  // Set Space Statistics
  Local<Value> name_value;
@@ -453,8 +468,12 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  page_statistics_array.size()),
  free_list_statistics_obj,
  };
- space_statistics_array.emplace_back(
- space_stats_tmpl->NewInstance(context, space_stats_values));
+ Local<Object> space_stats_object;
+ if (!NewDictionaryInstance(context, space_stats_tmpl, space_stats_values)
+ .ToLocal(&space_stats_object)) {
+ return MaybeLocal<Object>();
+ }
+ space_statistics_array.emplace_back(space_stats_object);
  }
 
  Local<Value> type_names_value;
@@ -474,7 +493,8 @@ static MaybeLocal<Object> ConvertHeapStatsToJSObject(
  space_statistics_array.size()),
  type_names_value};
 
- return heap_stats_tmpl->NewInstance(context, heap_statistics_values);
+ return NewDictionaryInstance(
+ context, heap_stats_tmpl, heap_statistics_values);
 }
 
 static void GetCppHeapStatistics(const FunctionCallbackInfo<Value>& args) {

src/node_worker.cc

@@ -32,13 +32,13 @@ using v8::Float64Array;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
+using v8::HeapStatistics;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::Locker;
 using v8::Maybe;
 using v8::MaybeLocal;
-using v8::Name;
 using v8::NewStringType;
 using v8::Null;
 using v8::Number;
@@ -878,7 +878,7 @@ void Worker::CpuUsage(const FunctionCallbackInfo<Value>& args) {
  } else {
  auto tmpl = env->cpu_usage_template();
  if (tmpl.IsEmpty()) {
- std::string_view names[] = {
+ static constexpr std::string_view names[] = {
  "user",
  "system",
  };
@@ -894,7 +894,10 @@ void Worker::CpuUsage(const FunctionCallbackInfo<Value>& args) {
  1e6 * cpu_usage_stats->ru_stime.tv_sec +
  cpu_usage_stats->ru_stime.tv_usec),
  };
- argv[1] = tmpl->NewInstance(env->context(), values);
+ if (!NewDictionaryInstance(env->context(), tmpl, values)
+ .ToLocal(&argv[1])) {
+ return;
+ }
  }
 
  taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);
@@ -1063,7 +1066,7 @@ void Worker::GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
  env](Environment* worker_env) mutable {
  // We create a unique pointer to HeapStatistics so that the actual object
  // it's not copied in the lambda, but only the pointer is.
- auto heap_stats = std::make_unique<v8::HeapStatistics>();
+ auto heap_stats = std::make_unique<HeapStatistics>();
  worker_env->isolate()->GetHeapStatistics(heap_stats.get());
 
  // Here, the worker thread temporarily owns the WorkerHeapStatisticsTaker
@@ -1096,7 +1099,7 @@ void Worker::GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
  "used_global_handles_size",
  "external_memory",
  };
- tmpl = v8::DictionaryTemplate::New(isolate, heap_stats_names);
+ tmpl = DictionaryTemplate::New(isolate, heap_stats_names);
  env->set_heap_statistics_template(tmpl);
  }
 
@@ -1117,10 +1120,12 @@ void Worker::GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
  Number::New(isolate, heap_stats->used_global_handles_size()),
  Number::New(isolate, heap_stats->external_memory())};
 
- DCHECK_EQ(arraysize(heap_stats_names), arraysize(heap_stats_values));
-
- Local<Value> args[] = {
- tmpl->NewInstance(env->context(), heap_stats_values)};
+ Local<Object> obj;
+ if (!NewDictionaryInstance(env->context(), tmpl, heap_stats_values)
+ .ToLocal(&obj)) {
+ return;
+ }
+ Local<Value> args[] = {obj};
  taker->get()->MakeCallback(
  env->ondone_string(), arraysize(args), args);
  // implicitly delete `taker`

src/util-inl.h

@@ -704,6 +704,16 @@ inline std::wstring ConvertToWideString(const std::string& str,
 }
 #endif // _WIN32
 
+inline v8::MaybeLocal<v8::Object> NewDictionaryInstance(
+ v8::Local<v8::Context> context,
+ v8::Local<v8::DictionaryTemplate> tmpl,
+ v8::MemorySpan<v8::MaybeLocal<v8::Value>> property_values) {
+ for (auto& value : property_values) {
+ if (value.IsEmpty()) return v8::MaybeLocal<v8::Object>();
+ }
+ return tmpl->NewInstance(context, property_values);
+}
+
 } // namespace node
 
 #endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS