fixup

Signed-off-by: Juan José Arboleda <soyjuanarbol@gmail.com>
nodejs · juanarbol · Mar 13, 2023 · Apr 1, 2023 · Apr 1, 2023 · 48d021824acfa84077dd5c3aefa3433a752ae249
commit 48d021824acfa84077dd5c3aefa3433a752ae249
diff --git a/deps/v8/include/v8-initialization.h b/deps/v8/include/v8-initialization.h
@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <string>
 
 #include "v8-callbacks.h"  // NOLINT(build/include_directory)
 #include "v8-internal.h"   // NOLINT(build/include_directory)
@@ -92,7 +93,12 @@ class V8_EXPORT V8 {
   /**
    * Gets V8 flags names and stores them in the provided vector.
    */
-  static std::vector<const char*> GetFlagsNames();
+  static std::vector<std::string> GetFlagsNames();
+
+  /**
+   * Gets a V8 flag comment
+   */
+  static const char* GetFlagComment(const char* flag_name);
 
   /** Get the version string. */
   static const char* GetVersion();

diff --git a/deps/v8/src/api/api.cc b/deps/v8/src/api/api.cc
@@ -45,6 +45,7 @@
 #include "src/common/globals.h"
 #include "src/compiler-dispatcher/lazy-compile-dispatcher.h"
 #include "src/date/date.h"
+#include "src/flags/flags.h"
 #include "src/objects/primitive-heap-object.h"
 #if V8_ENABLE_WEBASSEMBLY
 #include "src/debug/debug-wasm-objects.h"
@@ -687,10 +688,14 @@ void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) {
                                        HelpOptions(HelpOptions::kDontExit));
 }
 
-std::vector<const char*> V8::GetFlagsNames() {
+std::vector<std::string> V8::GetFlagsNames() {
   return i::FlagList::GetNames();
 }
 
+const char* V8::GetFlagComment(const char* flag_name) {
+  return i::FlagList::GetFlagComment(flag_name);
+}
+
 RegisteredExtension* RegisteredExtension::first_extension_ = nullptr;
 
 RegisteredExtension::RegisteredExtension(std::unique_ptr<Extension> extension)

diff --git a/deps/v8/src/flags/flags.cc b/deps/v8/src/flags/flags.cc
@@ -104,6 +104,15 @@ struct Flag {
 
   const char* name() const { return name_; }
 
+  std::string normalized_name() const {
+    std::string normalized_name_;
+    for (const char* p = name(); *p; ++p) {
+      normalized_name_ += NormalizeChar(*p);
+    }
+
+    return normalized_name_;
+  }
+
   const char* comment() const { return cmt_; }
 
   bool PointsTo(const void* ptr) const { return valptr_ == ptr; }
@@ -415,6 +424,13 @@ Flag* FindFlagByName(const char* name) {
   return nullptr;
 }
 
+const char* FindFlagComment(const char* name) {
+  for (size_t i = 0; i < kNumFlags; ++i) {
+    if (EqualNames(name, flags[i].name())) return flags[i].comment();
+  }
+  return nullptr;
+}
+
 Flag* FindFlagByPointer(const void* ptr) {
   for (size_t i = 0; i < kNumFlags; ++i) {
     if (flags[i].PointsTo(ptr)) return &flags[i];
@@ -834,17 +850,19 @@ void FlagList::PrintValues() {
 }
 
 // static
-std::vector<const char*> FlagList::GetNames() {
-  std::vector<const char*> stor;
-  for (const Flag& f : flags) {
-    std::string parsed_name;
-    FlagName flag_name = FlagName{f.name()};
-    for (const char* p = flag_name.name; *p; ++p) parsed_name += NormalizeChar(*p);
-    stor.push_back(parsed_name.c_str());
+std::vector<std::string> FlagList::GetNames() {
+  std::vector<std::string> stor;
+  for (Flag& flag : flags) {
+    stor.push_back(flag.normalized_name());
   }
+
   return stor;
 }
 
+const char* FlagList::GetFlagComment(const char* flag_name) {
+  return FindFlagComment(flag_name);
+}
+
 namespace {
 
 class ImplicationProcessor {

diff --git a/deps/v8/src/flags/flags.h b/deps/v8/src/flags/flags.h
@@ -133,7 +133,10 @@ class V8_EXPORT_PRIVATE FlagList {
   static void PrintValues();
 
   // Get all the flags names and store them in the privided vector.
-  static std::vector<const char*> GetNames();
+  static std::vector<std::string> GetNames();
+
+  // Get the flag comment
+  static const char* GetFlagComment(const char*);
 
   // Set flags as consequence of being implied by another flag.
   static void EnforceFlagImplications();

diff --git a/deps/v8/test/unittests/flags/flags-getters-setters.cc b/deps/v8/test/unittests/flags/flags-getters-setters.cc
@@ -0,0 +1,25 @@
+// Copyright 2023 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include <vector>
+#include <string>
+
+#include "include/v8-initialization.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+std::vector<std::string> v8_available_flags = v8::V8::GetFlagsNames();
+
+TEST(FlagGetterTest, FlagsGetter) {
+  // All flags should be normalized (using '-' instead of '_')
+  for (std::string& flag : v8_available_flags) {
+    EXPECT_EQ(flag.find('_'), std::string::npos);
+  }
+}
+
+TEST(FlagGetterTest, FlagsComment) {
+  // All flags should be normalized (using '-' instead of '_')
+  std::vector<std::string> v8_available_flags = v8::V8::GetFlagsNames();
+  for (std::string& flag : v8_available_flags) {
+    ASSERT_NE(v8::V8::GetFlagComment(flag.c_str()), nullptr);
+  }
+}
diff --git a/src/node.cc b/src/node.cc
@@ -927,6 +927,15 @@ InitializeOncePerProcessInternal(const std::vector<std::string>& args,
       return result;
     }
 
+    std::vector<std::string> v8_available_flags = v8::V8::GetFlagsNames();
+
+    for (size_t i = 0; i < v8_available_flags.size(); ++i) {
+      fprintf(stdout, "THE V8 FLAG IS: %s\n", v8_available_flags[i].c_str());
+      fprintf(stdout, "THE V8 FLAG comment: %s\n", v8::V8::GetFlagComment(v8_available_flags[i].c_str()));
+    }
+
+
+
     if (per_process::cli_options->print_v8_help) {
       V8::SetFlagsFromString("--help", static_cast<size_t>(6));
       result->exit_code_ = ExitCode::kNoFailure;

diff --git a/src/node_options.cc b/src/node_options.cc
@@ -740,11 +740,13 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
 PerIsolateOptionsParser::PerIsolateOptionsParser(
   const EnvironmentOptionsParser& eop) {
 
-  std::vector<const char*> v8_available_flags = v8::V8::GetFlagsNames();
-  for (size_t i = 0; i < v8_available_flags.size(); ++i) {
-    std::string v8Opt = "--";
-    v8Opt.append(v8_available_flags[i]);
-    AddOption(v8Opt.c_str(), "", V8Option{}, kAllowedInEnvvar);
+  std::vector<std::string> v8_available_flags = v8::V8::GetFlagsNames();
+  for (std::string& flag : v8_available_flags) {
+    std::string flagName = "--" + flag;
+    AddOption(flagName.c_str(),
+              v8::V8::GetFlagComment(flag.c_str()),
+              V8Option{},
+              kAllowedInEnvvar);
   }
 
   AddOption("--track-heap-objects",