src: rename Init and Start overloads to something more distinctive

In addition, move the `--help` and `--v8-help` processing out of
`StartNodeWithLoopAndArgs()` and process them earlier - right after
`InitializeNodeWithArgs()`, similar to how they are handled in
the legacy `Init()`.

PR-URL: #26499
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Refael Ackermann <refack@gmail.com>

src/api/environment.cc

@@ -225,7 +225,7 @@ Environment* CreateEnvironment(IsolateData* isolate_data,
       static_cast<Environment::Flags>(Environment::kIsMainThread |
                                       Environment::kOwnsProcessState |
                                       Environment::kOwnsInspector));
-  env->Start(per_process::v8_is_profiling);
+  env->InitializeLibuv(per_process::v8_is_profiling);
   env->ProcessCliArgs(args, exec_args);
   return env;
 }

src/env.cc

@@ -320,7 +320,7 @@ Environment::~Environment() {
   }
 }
 
-void Environment::Start(bool start_profiler_idle_notifier) {
+void Environment::InitializeLibuv(bool start_profiler_idle_notifier) {
   HandleScope handle_scope(isolate());
   Context::Scope context_scope(context());
 

src/env.h

@@ -675,7 +675,7 @@ class Environment {
               uint64_t thread_id = kNoThreadId);
   ~Environment();
 
-  void Start(bool start_profiler_idle_notifier);
+  void InitializeLibuv(bool start_profiler_idle_notifier);
   v8::MaybeLocal<v8::Object> ProcessCliArgs(
       const std::vector<std::string>& args,
       const std::vector<std::string>& exec_args);

src/node.cc

@@ -620,10 +620,10 @@ int ProcessGlobalArgs(std::vector<std::string>* args,
 
 static std::atomic_bool init_called{false};
 
-int Init(std::vector<std::string>* argv,
-         std::vector<std::string>* exec_argv,
-         std::vector<std::string>* errors) {
-  // Make sure Init() is called only once.
+int InitializeNodeWithArgs(std::vector<std::string>* argv,
+                           std::vector<std::string>* exec_argv,
+                           std::vector<std::string>* errors) {
+  // Make sure InitializeNodeWithArgs() is called only once.
   CHECK(!init_called.exchange(true));
 
   // Register built-in modules
@@ -734,7 +734,7 @@ void Init(int* argc,
 
   // This (approximately) duplicates some logic that has been moved to
   // node::Start(), with the difference that here we explicitly call `exit()`.
-  int exit_code = Init(&argv_, &exec_argv_, &errors);
+  int exit_code = InitializeNodeWithArgs(&argv_, &exec_argv_, &errors);
 
   for (const std::string& error : errors)
     fprintf(stderr, "%s: %s\n", argv_.at(0).c_str(), error.c_str());
@@ -769,9 +769,10 @@ void RunBeforeExit(Environment* env) {
     EmitBeforeExit(env);
 }
 
-inline int Start(Isolate* isolate, IsolateData* isolate_data,
-                 const std::vector<std::string>& args,
-                 const std::vector<std::string>& exec_args) {
+inline int StartNodeWithIsolate(Isolate* isolate,
+                                IsolateData* isolate_data,
+                                const std::vector<std::string>& args,
+                                const std::vector<std::string>& exec_args) {
   HandleScope handle_scope(isolate);
   Local<Context> context = NewContext(isolate);
   Context::Scope context_scope(context);
@@ -782,7 +783,7 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
       static_cast<Environment::Flags>(Environment::kIsMainThread |
                                       Environment::kOwnsProcessState |
                                       Environment::kOwnsInspector));
-  env.Start(per_process::v8_is_profiling);
+  env.InitializeLibuv(per_process::v8_is_profiling);
   env.ProcessCliArgs(args, exec_args);
 
 #if HAVE_INSPECTOR && NODE_USE_V8_PLATFORM
@@ -858,25 +859,15 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
   return exit_code;
 }
 
-inline int Start(uv_loop_t* event_loop,
-                 const std::vector<std::string>& args,
-                 const std::vector<std::string>& exec_args) {
+inline int StartNodeWithLoopAndArgs(uv_loop_t* event_loop,
+                                    const std::vector<std::string>& args,
+                                    const std::vector<std::string>& exec_args) {
   std::unique_ptr<ArrayBufferAllocator, decltype(&FreeArrayBufferAllocator)>
       allocator(CreateArrayBufferAllocator(), &FreeArrayBufferAllocator);
   Isolate* const isolate = NewIsolate(allocator.get(), event_loop);
   if (isolate == nullptr)
     return 12;  // Signal internal error.
 
-  if (per_process::cli_options->print_version) {
-    printf("%s\n", NODE_VERSION);
-    return 0;
-  }
-
-  if (per_process::cli_options->print_v8_help) {
-    V8::SetFlagsFromString("--help", 6);  // Doesn't return.
-    UNREACHABLE();
-  }
-
   int exit_code;
   {
     Locker locker(isolate);
@@ -894,7 +885,7 @@ inline int Start(uv_loop_t* event_loop,
       isolate->GetHeapProfiler()->StartTrackingHeapObjects(true);
     }
     exit_code =
-        Start(isolate, isolate_data.get(), args, exec_args);
+        StartNodeWithIsolate(isolate, isolate_data.get(), args, exec_args);
   }
 
   isolate->Dispose();
@@ -926,12 +917,22 @@ int Start(int argc, char** argv) {
   std::vector<std::string> errors;
   // This needs to run *before* V8::Initialize().
   {
-    const int exit_code = Init(&args, &exec_args, &errors);
+    const int exit_code = InitializeNodeWithArgs(&args, &exec_args, &errors);
     for (const std::string& error : errors)
       fprintf(stderr, "%s: %s\n", args.at(0).c_str(), error.c_str());
     if (exit_code != 0) return exit_code;
   }
 
+  if (per_process::cli_options->print_version) {
+    printf("%s\n", NODE_VERSION);
+    return 0;
+  }
+
+  if (per_process::cli_options->print_v8_help) {
+    V8::SetFlagsFromString("--help", 6);  // Doesn't return.
+    UNREACHABLE();
+  }
+
 #if HAVE_OPENSSL
   {
     std::string extra_ca_certs;
@@ -953,7 +954,7 @@ int Start(int argc, char** argv) {
   performance::performance_v8_start = PERFORMANCE_NOW();
   per_process::v8_initialized = true;
   const int exit_code =
-      Start(uv_default_loop(), args, exec_args);
+      StartNodeWithLoopAndArgs(uv_default_loop(), args, exec_args);
   per_process::v8_initialized = false;
   V8::Dispose();
 

src/node_worker.cc

@@ -284,7 +284,7 @@ void Worker::Run() {
         env_->set_abort_on_uncaught_exception(false);
         env_->set_worker_context(this);
 
-        env_->Start(profiler_idle_notifier_started_);
+        env_->InitializeLibuv(profiler_idle_notifier_started_);
         env_->ProcessCliArgs(std::vector<std::string>{},
                              std::move(exec_argv_));
       }