@encharm/cws 4.0.2 → 4.3.0

package/src/headers/{13 → 18}/node_options-inl.h

@@ -23,12 +23,14 @@ template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
                                        bool Options::* field,
-                                       OptionEnvvarSettings env_setting) {
+                                       OptionEnvvarSettings env_setting,
+                                       bool default_is_true) {
   options_.emplace(name,
                    OptionInfo{kBoolean,
                               std::make_shared<SimpleOptionField<bool>>(field),
                               env_setting,
-                              help_text});
+                              help_text,
+                              default_is_true});
 }
 
 template <typename Options>
@@ -138,10 +140,9 @@ void OptionsParser<Options>::Implies(const char* from,
                                      const char* to) {
   auto it = options_.find(to);
   CHECK_NE(it, options_.end());
-  CHECK_EQ(it->second.type, kBoolean);
-  implications_.emplace(from, Implication {
-    it->second.field, true
-  });
+  CHECK(it->second.type == kBoolean || it->second.type == kV8Option);
+  implications_.emplace(
+      from, Implication{it->second.type, to, it->second.field, true});
 }
 
 template <typename Options>
@@ -150,9 +151,8 @@ void OptionsParser<Options>::ImpliesNot(const char* from,
   auto it = options_.find(to);
   CHECK_NE(it, options_.end());
   CHECK_EQ(it->second.type, kBoolean);
-  implications_.emplace(from, Implication {
-    it->second.field, false
-  });
+  implications_.emplace(
+      from, Implication{it->second.type, to, it->second.field, false});
 }
 
 template <typename Options>
@@ -188,7 +188,8 @@ auto OptionsParser<Options>::Convert(
   return OptionInfo{original.type,
                     Convert(original.field, get_child),
                     original.env_setting,
-                    original.help_text};
+                    original.help_text,
+                    original.default_is_true};
 }
 
 template <typename Options>
@@ -196,9 +197,11 @@ template <typename ChildOptions>
 auto OptionsParser<Options>::Convert(
     typename OptionsParser<ChildOptions>::Implication original,
     ChildOptions* (Options::* get_child)()) {
-  return Implication {
-    Convert(original.target_field, get_child),
-    original.target_value
+  return Implication{
+      original.type,
+      original.name,
+      Convert(original.target_field, get_child),
+      original.target_value,
   };
 }
 
@@ -225,6 +228,10 @@ inline std::string RequiresArgumentErr(const std::string& arg) {
   return arg + " requires an argument";
 }
 
+inline std::string NegationImpliesBooleanError(const std::string& arg) {
+  return arg + " is an invalid negation because it is not a boolean option";
+}
+
 // We store some of the basic information around a single Parse call inside
 // this struct, to separate storage of command line arguments and their
 // handling. In particular, this makes it easier to introduce 'synthetic'
@@ -325,6 +332,13 @@ void OptionsParser<Options>::Parse(
         name[i] = '-';
     }
 
+    // Convert --no-foo to --foo and keep in mind that we're negating.
+    bool is_negation = false;
+    if (name.find("--no-") == 0) {
+      name.erase(2, 3);  // remove no-
+      is_negation = true;
+    }
+
     {
       auto it = aliases_.end();
       // Expand aliases:
@@ -366,20 +380,36 @@ void OptionsParser<Options>::Parse(
       break;
     }
 
+    {
+      std::string implied_name = name;
+      if (is_negation) {
+        // Implications for negated options are defined with "--no-".
+        implied_name.insert(2, "no-");
+      }
+      auto implications = implications_.equal_range(implied_name);
+      for (auto it = implications.first; it != implications.second; ++it) {
+        if (it->second.type == kV8Option) {
+          v8_args->push_back(it->second.name);
+        } else {
+          *it->second.target_field->template Lookup<bool>(options) =
+              it->second.target_value;
+        }
+      }
+    }
+
     if (it == options_.end()) {
       v8_args->push_back(arg);
       continue;
     }
 
-    {
-      auto implications = implications_.equal_range(name);
-      for (auto it = implications.first; it != implications.second; ++it) {
-        *it->second.target_field->template Lookup<bool>(options) =
-            it->second.target_value;
-      }
+    const OptionInfo& info = it->second;
+
+    // Some V8 options can be negated and they are validated by V8 later.
+    if (is_negation && info.type != kBoolean && info.type != kV8Option) {
+      errors->push_back(NegationImpliesBooleanError(arg));
+      break;
     }
 
-    const OptionInfo& info = it->second;
     std::string value;
     if (info.type != kBoolean && info.type != kNoOp && info.type != kV8Option) {
       if (equals_index != std::string::npos) {
@@ -408,7 +438,7 @@ void OptionsParser<Options>::Parse(
 
     switch (info.type) {
       case kBoolean:
-        *Lookup<bool>(info.field, options) = true;
+        *Lookup<bool>(info.field, options) = !is_negation;
         break;
       case kInteger:
         *Lookup<int64_t>(info.field, options) = std::atoll(value.c_str());

package/src/headers/{13 → 18}/node_options.h

@@ -11,6 +11,10 @@
 #include "node_mutex.h"
 #include "util.h"
 
+#if HAVE_OPENSSL
+#include "openssl/opensslv.h"
+#endif
+
 namespace node {
 
 class HostPort {
@@ -100,26 +104,32 @@ class DebugOptions : public Options {
 class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
+  std::vector<std::string> conditions;
+  std::string dns_result_order;
   bool enable_source_maps = false;
-  bool experimental_json_modules = false;
-  bool experimental_modules = false;
+  bool experimental_fetch = true;
+  bool experimental_global_web_crypto = false;
+  bool experimental_https_modules = false;
   std::string experimental_specifier_resolution;
-  std::string es_module_specifier_resolution;
   bool experimental_wasm_modules = false;
   bool experimental_import_meta_resolve = false;
   std::string module_type;
   std::string experimental_policy;
   std::string experimental_policy_integrity;
-  bool has_policy_integrity_string;
-  bool experimental_repl_await = false;
+  bool has_policy_integrity_string = false;
+  bool experimental_repl_await = true;
   bool experimental_vm_modules = false;
   bool expose_internals = false;
+  bool force_node_api_uncaught_exceptions_policy = false;
   bool frozen_intrinsics = false;
+  int64_t heap_snapshot_near_heap_limit = 0;
   std::string heap_snapshot_signal;
   uint64_t max_http_header_size = 16 * 1024;
-  bool no_deprecation = false;
-  bool no_force_async_hooks_checks = false;
-  bool no_warnings = false;
+  bool deprecation = true;
+  bool force_async_hooks_checks = true;
+  bool allow_native_addons = true;
+  bool global_search_paths = true;
+  bool warnings = true;
   bool force_context_aware = false;
   bool pending_deprecation = false;
   bool preserve_symlinks = false;
@@ -138,16 +148,27 @@ class EnvironmentOptions : public Options {
   bool heap_prof = false;
 #endif  // HAVE_INSPECTOR
   std::string redirect_warnings;
+  std::string diagnostic_dir;
+  bool test_runner = false;
+  bool test_only = false;
   bool test_udp_no_try_send = false;
   bool throw_deprecation = false;
+  bool trace_atomics_wait = false;
   bool trace_deprecation = false;
   bool trace_exit = false;
   bool trace_sync_io = false;
   bool trace_tls = false;
   bool trace_uncaught = false;
   bool trace_warnings = false;
+  bool extra_info_on_fatal_exception = true;
   std::string unhandled_rejections;
   std::string userland_loader;
+  bool verify_base_objects =
+#ifdef DEBUG
+      true;
+#else
+      false;
+#endif  // DEBUG
 
   bool syntax_check_only = false;
   bool has_eval_string = false;
@@ -183,7 +204,6 @@ class PerIsolateOptions : public Options {
  public:
   std::shared_ptr<EnvironmentOptions> per_env { new EnvironmentOptions() };
   bool track_heap_objects = false;
-  bool no_node_snapshot = false;
   bool report_uncaught_exception = false;
   bool report_on_signal = false;
   std::string report_signal = "SIGUSR2";
@@ -210,6 +230,11 @@ class PerProcessOptions : public Options {
   bool zero_fill_all_buffers = false;
   bool debug_arraybuffer_allocations = false;
   std::string disable_proto;
+  bool build_snapshot = false;
+  // We enable the shared read-only heap which currently requires that the
+  // snapshot used in different isolates in the same process to be the same.
+  // Therefore --node-snapshot is a per-process option.
+  bool node_snapshot = true;
 
   std::vector<std::string> security_reverts;
   bool print_bash_completion = false;
@@ -222,10 +247,12 @@ class PerProcessOptions : public Options {
 #endif
 
   // Per-process because they affect singleton OpenSSL shared library state,
-  // or are used once during process intialization.
+  // or are used once during process initialization.
 #if HAVE_OPENSSL
   std::string openssl_config;
   std::string tls_cipher_list = DEFAULT_CIPHER_LIST_CORE;
+  int64_t secure_heap = 0;
+  int64_t secure_heap_min = 2;
 #ifdef NODE_OPENSSL_CERT_STORE
   bool ssl_openssl_cert_store = true;
 #else
@@ -233,10 +260,11 @@ class PerProcessOptions : public Options {
 #endif
   bool use_openssl_ca = false;
   bool use_bundled_ca = false;
-#if NODE_FIPS_MODE
   bool enable_fips_crypto = false;
   bool force_fips_crypto = false;
 #endif
+#if OPENSSL_VERSION_MAJOR >= 3
+  bool openssl_legacy_provider = false;
 #endif
 
   // Per-process because reports can be triggered outside a known V8 context.
@@ -290,7 +318,8 @@ class OptionsParser {
   void AddOption(const char* name,
                  const char* help_text,
                  bool Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
+                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment,
+                 bool default_is_true = false);
   void AddOption(const char* name,
                  const char* help_text,
                  uint64_t Options::* field,
@@ -413,11 +442,14 @@ class OptionsParser {
     std::shared_ptr<BaseOptionField> field;
     OptionEnvvarSettings env_setting;
     std::string help_text;
+    bool default_is_true = false;
   };
 
   // An implied option is composed of the information on where to store a
   // specific boolean value (if another specific option is encountered).
   struct Implication {
+    OptionType type;
+    std::string name;
     std::shared_ptr<BaseOptionField> target_field;
     bool target_value;
   };
@@ -444,7 +476,7 @@ class OptionsParser {
   template <typename OtherOptions>
   friend class OptionsParser;
 
-  friend void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
+  friend void GetCLIOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
   friend std::string GetBashCompletion();
 };
 
@@ -460,7 +492,7 @@ void Parse(
 namespace per_process {
 
 extern Mutex cli_options_mutex;
-extern std::shared_ptr<PerProcessOptions> cli_options;
+extern NODE_EXTERN_PRIVATE std::shared_ptr<PerProcessOptions> cli_options;
 
 }  // namespace per_process
 

package/src/headers/18/node_perf.h

@@ -0,0 +1,168 @@
+#ifndef SRC_NODE_PERF_H_
+#define SRC_NODE_PERF_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object-inl.h"
+#include "histogram.h"
+#include "node.h"
+#include "node_internals.h"
+#include "node_perf_common.h"
+
+#include "v8.h"
+#include "uv.h"
+
+#include <string>
+
+namespace node {
+
+class Environment;
+class ExternalReferenceRegistry;
+
+namespace performance {
+
+extern const uint64_t timeOrigin;
+
+inline const char* GetPerformanceMilestoneName(
+    PerformanceMilestone milestone) {
+  switch (milestone) {
+#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
+  NODE_PERFORMANCE_MILESTONES(V)
+#undef V
+    default:
+      UNREACHABLE();
+  }
+}
+
+inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
+#define V(name, label)                                                        \
+  if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
+  NODE_PERFORMANCE_MILESTONES(V)
+#undef V
+  return NODE_PERFORMANCE_MILESTONE_INVALID;
+}
+
+inline const char* GetPerformanceEntryTypeName(
+    PerformanceEntryType type) {
+  switch (type) {
+#define V(name, label) case NODE_PERFORMANCE_ENTRY_TYPE_##name: return label;
+  NODE_PERFORMANCE_ENTRY_TYPES(V)
+#undef V
+    default:
+      UNREACHABLE();
+  }
+}
+
+inline PerformanceEntryType ToPerformanceEntryTypeEnum(
+    const char* type) {
+#define V(name, label)                                                        \
+  if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
+  NODE_PERFORMANCE_ENTRY_TYPES(V)
+#undef V
+  return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
+}
+
+enum PerformanceGCKind {
+  NODE_PERFORMANCE_GC_MAJOR = v8::GCType::kGCTypeMarkSweepCompact,
+  NODE_PERFORMANCE_GC_MINOR = v8::GCType::kGCTypeScavenge,
+  NODE_PERFORMANCE_GC_INCREMENTAL = v8::GCType::kGCTypeIncrementalMarking,
+  NODE_PERFORMANCE_GC_WEAKCB = v8::GCType::kGCTypeProcessWeakCallbacks
+};
+
+enum PerformanceGCFlags {
+  NODE_PERFORMANCE_GC_FLAGS_NO =
+    v8::GCCallbackFlags::kNoGCCallbackFlags,
+  NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
+    v8::GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
+  NODE_PERFORMANCE_GC_FLAGS_FORCED =
+    v8::GCCallbackFlags::kGCCallbackFlagForced,
+  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
+    v8::GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
+    v8::GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
+    v8::GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
+  NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
+    v8::GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
+};
+
+template <typename Traits>
+struct PerformanceEntry {
+  using Details = typename Traits::Details;
+  std::string name;
+  double start_time;
+  double duration;
+  Details details;
+
+  PerformanceEntry(
+    const std::string& name_,
+    double start_time_,
+    double duration_,
+    const Details& details_)
+    : name(name_),
+      start_time(start_time_),
+      duration(duration_),
+      details(details_) {}
+
+  static v8::MaybeLocal<v8::Object> GetDetails(
+      Environment* env,
+      const PerformanceEntry<Traits>& entry) {
+    return Traits::GetDetails(env, entry);
+  }
+
+  void Notify(Environment* env) {
+    v8::HandleScope handle_scope(env->isolate());
+    v8::Context::Scope scope(env->context());
+    AliasedUint32Array& observers = env->performance_state()->observers;
+    if (env->performance_entry_callback().IsEmpty() ||
+        !observers[Traits::kType]) {
+      return;
+    }
+
+    v8::Local<v8::Object> detail;
+    if (!Traits::GetDetails(env, *this).ToLocal(&detail)) {
+      // TODO(@jasnell): Handle the error here
+      return;
+    }
+
+    v8::Local<v8::Value> argv[] = {
+      OneByteString(env->isolate(), name.c_str()),
+      OneByteString(env->isolate(), GetPerformanceEntryTypeName(Traits::kType)),
+      v8::Number::New(env->isolate(), start_time),
+      v8::Number::New(env->isolate(), duration),
+      detail
+    };
+
+    node::MakeSyncCallback(
+        env->isolate(),
+        env->context()->Global(),
+        env->performance_entry_callback(),
+        arraysize(argv),
+        argv);
+  }
+};
+
+struct GCPerformanceEntryTraits {
+  static constexpr PerformanceEntryType kType =
+      NODE_PERFORMANCE_ENTRY_TYPE_GC;
+  struct Details {
+    PerformanceGCKind kind;
+    PerformanceGCFlags flags;
+
+    Details(PerformanceGCKind kind_, PerformanceGCFlags flags_)
+        : kind(kind_), flags(flags_) {}
+  };
+
+  static v8::MaybeLocal<v8::Object> GetDetails(
+      Environment* env,
+      const PerformanceEntry<GCPerformanceEntryTraits>& entry);
+};
+
+using GCPerformanceEntry = PerformanceEntry<GCPerformanceEntryTraits>;
+
+}  // namespace performance
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PERF_H_

package/src/headers/{12 → 18}/node_perf_common.h

@@ -3,11 +3,13 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "aliased_buffer.h"
 #include "node.h"
 #include "uv.h"
 #include "v8.h"
 
 #include <algorithm>
+#include <iostream>
 #include <map>
 #include <string>
 
@@ -30,13 +32,11 @@ extern uint64_t performance_v8_start;
 
 
 #define NODE_PERFORMANCE_ENTRY_TYPES(V)                                       \
-  V(NODE, "node")                                                             \
-  V(MARK, "mark")                                                             \
-  V(MEASURE, "measure")                                                       \
   V(GC, "gc")                                                                 \
-  V(FUNCTION, "function")                                                     \
+  V(HTTP, "http")                                                             \
   V(HTTP2, "http2")                                                           \
-  V(HTTP, "http")
+  V(NET, "net")                                                               \
+  V(DNS, "dns")
 
 enum PerformanceMilestone {
 #define V(name, _) NODE_PERFORMANCE_MILESTONE_##name,
@@ -54,23 +54,17 @@ enum PerformanceEntryType {
 
 class PerformanceState {
  public:
-  explicit PerformanceState(v8::Isolate* isolate) :
-    root(
-      isolate,
-      sizeof(performance_state_internal)),
-    milestones(
-      isolate,
-      offsetof(performance_state_internal, milestones),
-      NODE_PERFORMANCE_MILESTONE_INVALID,
-      root),
-    observers(
-      isolate,
-      offsetof(performance_state_internal, observers),
-      NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
-      root) {
-    for (size_t i = 0; i < milestones.Length(); i++)
-      milestones[i] = -1.;
-  }
+  struct SerializeInfo {
+    AliasedBufferIndex root;
+    AliasedBufferIndex milestones;
+    AliasedBufferIndex observers;
+  };
+
+  explicit PerformanceState(v8::Isolate* isolate, const SerializeInfo* info);
+  SerializeInfo Serialize(v8::Local<v8::Context> context,
+                          v8::SnapshotCreator* creator);
+  void Deserialize(v8::Local<v8::Context> context);
+  friend std::ostream& operator<<(std::ostream& o, const SerializeInfo& i);
 
   AliasedUint8Array root;
   AliasedFloat64Array milestones;

package/src/headers/{12 → 18}/node_platform.h

@@ -11,7 +11,6 @@
 #include "libplatform/libplatform.h"
 #include "node.h"
 #include "node_mutex.h"
-#include "tracing/agent.h"
 #include "uv.h"
 
 namespace node {
@@ -52,12 +51,14 @@ struct DelayedTask {
 
 // This acts as the foreground task runner for a given Isolate.
 class PerIsolatePlatformData :
+    public IsolatePlatformDelegate,
     public v8::TaskRunner,
     public std::enable_shared_from_this<PerIsolatePlatformData> {
  public:
   PerIsolatePlatformData(v8::Isolate* isolate, uv_loop_t* loop);
   ~PerIsolatePlatformData() override;
 
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() override;
   void PostTask(std::unique_ptr<v8::Task> task) override;
   void PostIdleTask(std::unique_ptr<v8::IdleTask> task) override;
   void PostDelayedTask(std::unique_ptr<v8::Task> task,
@@ -137,8 +138,9 @@ class WorkerThreadsTaskRunner {
 class NodePlatform : public MultiIsolatePlatform {
  public:
   NodePlatform(int thread_pool_size,
-               node::tracing::TracingController* tracing_controller);
-  ~NodePlatform() override = default;
+               v8::TracingController* tracing_controller,
+               v8::PageAllocator* page_allocator = nullptr);
+  ~NodePlatform() override;
 
   void DrainTasks(v8::Isolate* isolate) override;
   void Shutdown();
@@ -148,21 +150,19 @@ class NodePlatform : public MultiIsolatePlatform {
   void CallOnWorkerThread(std::unique_ptr<v8::Task> task) override;
   void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> task,
                                  double delay_in_seconds) override;
-  void CallOnForegroundThread(v8::Isolate* isolate, v8::Task* task) override {
-    UNREACHABLE();
-  }
-  void CallDelayedOnForegroundThread(v8::Isolate* isolate,
-                                     v8::Task* task,
-                                     double delay_in_seconds) override {
-    UNREACHABLE();
-  }
   bool IdleTasksEnabled(v8::Isolate* isolate) override;
   double MonotonicallyIncreasingTime() override;
   double CurrentClockTimeMillis() override;
-  node::tracing::TracingController* GetTracingController() override;
+  v8::TracingController* GetTracingController() override;
   bool FlushForegroundTasks(v8::Isolate* isolate) override;
+  std::unique_ptr<v8::JobHandle> PostJob(
+      v8::TaskPriority priority,
+      std::unique_ptr<v8::JobTask> job_task) override;
 
   void RegisterIsolate(v8::Isolate* isolate, uv_loop_t* loop) override;
+  void RegisterIsolate(v8::Isolate* isolate,
+                       IsolatePlatformDelegate* delegate) override;
+
   void UnregisterIsolate(v8::Isolate* isolate) override;
   void AddIsolateFinishedCallback(v8::Isolate* isolate,
                                   void (*callback)(void*), void* data) override;
@@ -171,16 +171,21 @@ class NodePlatform : public MultiIsolatePlatform {
       v8::Isolate* isolate) override;
 
   Platform::StackTracePrinter GetStackTracePrinter() override;
+  v8::PageAllocator* GetPageAllocator() override;
 
  private:
-  std::shared_ptr<PerIsolatePlatformData> ForIsolate(v8::Isolate* isolate);
+  IsolatePlatformDelegate* ForIsolate(v8::Isolate* isolate);
+  std::shared_ptr<PerIsolatePlatformData> ForNodeIsolate(v8::Isolate* isolate);
 
   Mutex per_isolate_mutex_;
-  std::unordered_map<v8::Isolate*,
-                     std::shared_ptr<PerIsolatePlatformData>> per_isolate_;
+  using DelegatePair = std::pair<
+    IsolatePlatformDelegate*, std::shared_ptr<PerIsolatePlatformData>>;
+  std::unordered_map<v8::Isolate*, DelegatePair> per_isolate_;
 
-  node::tracing::TracingController* tracing_controller_;
+  v8::TracingController* tracing_controller_;
+  v8::PageAllocator* page_allocator_;
   std::shared_ptr<WorkerThreadsTaskRunner> worker_thread_task_runner_;
+  bool has_shut_down_ = false;
 };
 
 }  // namespace node

package/src/headers/18/node_process-inl.h

@@ -0,0 +1,26 @@
+#ifndef SRC_NODE_PROCESS_INL_H_
+#define SRC_NODE_PROCESS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_process.h"
+#include "v8.h"
+#include "debug_utils-inl.h"
+
+namespace node {
+
+// Call process.emitWarning(str), fmt is a snprintf() format string
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args) {
+  std::string warning = SPrintF(fmt, std::forward<Args>(args)...);
+
+  return ProcessEmitWarningGeneric(env, warning.c_str());
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PROCESS_INL_H_