Better default value name hint for vector flags

These look like "--instance-name=NAME[,NAME...]" now

Assisted-by: Gemini

Author: jemoreira

base/cvd/cuttlefish/flag_parser/flag.cpp

@@ -144,6 +144,8 @@ const std::string& Flag::Description() const { return help_; }
 
 std::string Flag::CurrentValue() const { return getter_(); }
 
+const std::string& Flag::ValueNameHint() const { return value_name_hint_; }
+
 Flag::Flag(std::string name, Flag::Style style) : style_(style) {
   ValidateAlias(name);
   value_name_hint_ = DefaultValueNameHint(name);

base/cvd/cuttlefish/flag_parser/flag.h

@@ -62,6 +62,7 @@ class Flag {
   std::string Synopsis() const;
   const std::string& Description() const;
   std::string CurrentValue() const;
+  const std::string& ValueNameHint() const;
 
  private:
   enum class Style {

base/cvd/cuttlefish/flag_parser/gflags_compat.cpp

@@ -26,10 +26,12 @@
 #include <string>
 #include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "absl/log/log.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/str_split.h"
@@ -202,6 +204,11 @@ std::string XmlEscape(const std::string& s) {
   return absl::StrReplaceAll(s, {{"<", "&lt;"}, {">", "&gt;"}});
 }
 
+Flag WithVectorNameValueHint(Flag flag) {
+  std::string hint = flag.ValueNameHint();
+  return std::move(flag).ValueNameHint(absl::StrCat(hint, "[,", hint, "...]"));
+}
+
 }  // namespace
 
 void WriteGflagsCompatXml(const Flag& flag, std::ostream& out) {
@@ -299,16 +306,19 @@ Flag GflagsCompatFlag(const std::string& name, bool& value) {
 
 Flag GflagsCompatFlag(const std::string& name,
                       std::vector<std::string>& value) {
-  return GflagsCompatFlagImpl<std::string>(name, value, "");
+  return WithVectorNameValueHint(
+      GflagsCompatFlagImpl<std::string>(name, value, ""));
 }
 
 Flag GflagsCompatFlag(const std::string& name, std::vector<unsigned>& value) {
-  return GflagsCompatFlagImpl<unsigned>(name, value, 0);
+  return WithVectorNameValueHint(
+      GflagsCompatFlagImpl<unsigned>(name, value, 0));
 }
 
 Flag GflagsCompatFlag(const std::string& name, std::vector<bool>& value,
                       const bool default_value) {
-  return GflagsCompatFlagImpl(name, value, default_value);
+  return WithVectorNameValueHint(
+      GflagsCompatFlagImpl(name, value, default_value));
 }
 
 Flag GflagsCompatFlag(const std::string& name,
@@ -351,13 +361,13 @@ Flag GflagsCompatFlag(const std::string& name, std::optional<bool>& value,
 Flag GflagsCompatFlag(const std::string& name,
                       std::optional<std::vector<std::string>>& value,
                       CoerceToNullopt opt) {
-  return GflagsCompatFlagImpl(name, value, opt);
+  return WithVectorNameValueHint(GflagsCompatFlagImpl(name, value, opt));
 }
 
 Flag GflagsCompatFlag(const std::string& name,
                       std::optional<std::vector<unsigned>>& value,
                       CoerceToNullopt opt) {
-  return GflagsCompatFlagImpl(name, value, opt);
+  return WithVectorNameValueHint(GflagsCompatFlagImpl(name, value, opt));
 }
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/flag_parser/gflags_compat_test.cpp

@@ -561,4 +561,34 @@ TEST(FlagParser, OptionalInt64Flag_NotPresent) {
   ASSERT_FALSE(value.has_value());
 }
 
+TEST(FlagParser, VectorFlagValueNameHint_StringVector) {
+  std::vector<std::string> string_vec;
+  auto flag = GflagsCompatFlag("string-vec", string_vec);
+  EXPECT_EQ(flag.Synopsis(), "--string-vec=VEC[,VEC...]");
+}
+
+TEST(FlagParser, VectorFlagValueNameHint_UnsignedVector) {
+  std::vector<unsigned> unsigned_vec;
+  auto flag = GflagsCompatFlag("unsigned-vec", unsigned_vec);
+  EXPECT_EQ(flag.Synopsis(), "--unsigned-vec=VEC[,VEC...]");
+}
+
+TEST(FlagParser, VectorFlagValueNameHint_BoolVector) {
+  std::vector<bool> bool_vec;
+  auto flag = GflagsCompatFlag("bool-vec", bool_vec, true);
+  EXPECT_EQ(flag.Synopsis(), "--bool-vec=VEC[,VEC...]");
+}
+
+TEST(FlagParser, VectorFlagValueNameHint_OptionalStringVector) {
+  std::optional<std::vector<std::string>> opt_string_vec;
+  auto flag = GflagsCompatFlag("opt-string-vec", opt_string_vec);
+  EXPECT_EQ(flag.Synopsis(), "--opt-string-vec=VEC[,VEC...]");
+}
+
+TEST(FlagParser, VectorFlagValueNameHint_OptionalUnsignedVector) {
+  std::optional<std::vector<unsigned>> opt_unsigned_vec;
+  auto flag = GflagsCompatFlag("opt-unsigned-vec", opt_unsigned_vec);
+  EXPECT_EQ(flag.Synopsis(), "--opt-unsigned-vec=VEC[,VEC...]");
+}
+
 }  // namespace cuttlefish