Add native ABSL_FLAG support for std::vector of numeric types.

C++ ADL rules prevent callers outside Abseil from defining
`AbslParseFlag` or `AbslUnparseFlag` overloads for `std::vector<T>`,
forcing callers who need comma-separated numeric list flags to use
`std::vector<std::string>` or `std::string` with manual post-parse
conversion or custom wrapper types that bypass eager validation during
`absl::ParseCommandLine()`.

Add `AbslParseFlag` and `AbslUnparseFlag` overloads in
`absl::flags_internal` for `std::vector<T>` across the 10 integral
types (`short`, `unsigned short`, `int`, `unsigned int`, `long`,
`unsigned long`, `long long`, `unsigned long long`, `absl::int128`,
`absl::uint128`, covering `int16_t` through `uint64_t` and `size_t`)
and 2 floating-point types (`float`, `double`) already supported as
scalar Abseil flags. Unconstrained `std::vector<T>`,
`std::vector<bool>`, and 8-bit character types (`char`, `int8_t`,
`uint8_t`) remain unsupported.

Empty input (`""`) parses as an empty vector, while non-empty input
splits on `','` and delegates each token to scalar `absl::ParseFlag()`,
allowing surrounding ASCII whitespace on elements while rejecting
whitespace-only strings, empty tokens, and trailing commas. Repeated
flags overwrite previous values.

PiperOrigin-RevId: 1022881182
diff --git a/absl/flags/config.h b/absl/flags/config.h
index 14c4235..b5d6a95 100644
--- a/absl/flags/config.h
+++ b/absl/flags/config.h
@@ -13,6 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 #ifndef ABSL_FLAGS_CONFIG_H_
 #define ABSL_FLAGS_CONFIG_H_
 
@@ -60,9 +62,22 @@
   A(double, double)                          \
   A(float, float)
 
-#define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \
-  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)         \
-  A(std::string, std_string)                   \
+#define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A)                     \
+  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)                             \
+  A(std::string, std_string)                                       \
+  A(std::vector<short>, std_vector_of_short) /* NOLINT */          \
+  A(std::vector<unsigned short>, /* NOLINT */                      \
+    std_vector_of_unsigned_short)                                  \
+  A(std::vector<int>, std_vector_of_int)                           \
+  A(std::vector<unsigned int>, std_vector_of_unsigned_int)         \
+  A(std::vector<long>, std_vector_of_long) /* NOLINT */            \
+  A(std::vector<unsigned long>, /* NOLINT */                       \
+    std_vector_of_unsigned_long)                                   \
+  A(std::vector<long long>, std_vector_of_long_long) /* NOLINT */  \
+  A(std::vector<unsigned long long>, /* NOLINT */                  \
+    std_vector_of_unsigned_long_long)                              \
+  A(std::vector<float>, std_vector_of_float)                       \
+  A(std::vector<double>, std_vector_of_double)                     \
   A(std::vector<std::string>, std_vector_of_string)
 
 #endif  // ABSL_FLAGS_CONFIG_H_
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc
index 199577e..666b86d 100644
--- a/absl/flags/flag_test.cc
+++ b/absl/flags/flag_test.cc
@@ -132,6 +132,10 @@
             flags::FlagValueStorageKind::kHeapAllocated);
   EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(),
             flags::FlagValueStorageKind::kHeapAllocated);
+  EXPECT_EQ(flags::StorageKind<std::vector<int>>(),
+            flags::FlagValueStorageKind::kHeapAllocated);
+  EXPECT_EQ(flags::StorageKind<std::vector<double>>(),
+            flags::FlagValueStorageKind::kHeapAllocated);
 
   EXPECT_EQ(flags::StorageKind<absl::int128>(),
             flags::FlagValueStorageKind::kSequenceLocked);
@@ -1465,3 +1469,68 @@
 }
 
 }  // namespace
+
+ABSL_FLAG(std::vector<int32_t>, numeric_vec_empty, {}, "empty int32 vector");
+ABSL_FLAG(std::vector<int64_t>, numeric_vec_int64,
+          std::vector<int64_t>({1, 2, 3}), "int64 vector");
+ABSL_FLAG(std::vector<size_t>, numeric_vec_size_t,
+          std::vector<size_t>({10, 20}), "size_t vector");
+ABSL_FLAG(std::vector<absl::int128>, numeric_vec_int128,
+          std::vector<absl::int128>({-1, 2}), "int128 vector");
+ABSL_FLAG(std::vector<double>, numeric_vec_double,
+          std::vector<double>({0.5, -1.5}), "double vector");
+
+namespace {
+
+TEST_F(FlagTest, TestNumericVectorFlags) {
+  EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_empty), std::vector<int32_t>{});
+  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_empty)
+                .DefaultValue(),
+            "");
+
+  EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64),
+            (std::vector<int64_t>{1, 2, 3}));
+  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_int64)
+                .DefaultValue(),
+            "1,2,3");
+  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_int64)
+                .CurrentValue(),
+            "1,2,3");
+
+  EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_size_t),
+            (std::vector<size_t>{10, 20}));
+  EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int128),
+            (std::vector<absl::int128>{-1, 2}));
+  EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_double),
+            (std::vector<double>{0.5, -1.5}));
+
+  {
+    absl::FlagSaver saver;
+    absl::SetFlag(&FLAGS_numeric_vec_int64, std::vector<int64_t>{4, 5});
+    EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64),
+              (std::vector<int64_t>{4, 5}));
+    EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_numeric_vec_int64)
+                  .CurrentValue(),
+              "4,5");
+  }
+  EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64),
+            (std::vector<int64_t>{1, 2, 3}));
+
+  if constexpr (!kStrippedFlagNames) {
+    absl::CommandLineFlag* handle =
+        absl::FindCommandLineFlag("numeric_vec_int64");
+    ASSERT_NE(handle, nullptr);
+    EXPECT_EQ(*handle->TryGet<std::vector<int64_t>>(),
+              (std::vector<int64_t>{1, 2, 3}));
+
+    std::string err;
+    EXPECT_TRUE(handle->ParseFrom("10, 20", &err));
+    EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64),
+              (std::vector<int64_t>{10, 20}));
+
+    EXPECT_TRUE(handle->ParseFrom("", &err));
+    EXPECT_EQ(absl::GetFlag(FLAGS_numeric_vec_int64), std::vector<int64_t>{});
+  }
+}
+
+}  // namespace
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index b565aaf..fd23687 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -28,6 +28,7 @@
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
+#include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/base/call_once.h"
diff --git a/absl/flags/marshalling.cc b/absl/flags/marshalling.cc
index cb829a4..d64448a 100644
--- a/absl/flags/marshalling.cc
+++ b/absl/flags/marshalling.cc
@@ -157,7 +157,7 @@
 }
 
 // --------------------------------------------------------------------
-// AbslParseFlag for vector of strings.
+// AbslParseFlag for vector of strings and numeric types.
 
 bool AbslParseFlag(absl::string_view text, std::vector<std::string>* dst,
                    std::string*) {
@@ -171,6 +171,84 @@
   return true;
 }
 
+namespace {
+
+template <typename T>
+bool ParseFlagVectorImpl(absl::string_view text, std::vector<T>* dst,
+                         std::string* err) {
+  dst->clear();
+  if (text.empty()) return true;
+  for (const absl::string_view element :
+       absl::StrSplit(text, ',', absl::AllowEmpty())) {
+    T value;
+    if (!absl::ParseFlag(element, &value, err)) return false;
+    dst->push_back(value);
+  }
+  return true;
+}
+
+template <typename T>
+std::string UnparseFlagVectorImpl(const std::vector<T>& val) {
+  return absl::StrJoin(val, ",", [](std::string* out, T v) {
+    absl::StrAppend(out, absl::UnparseFlag(v));
+  });
+}
+
+}  // namespace
+
+bool AbslParseFlag(absl::string_view text, std::vector<short>* dst,  // NOLINT
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text,
+                   std::vector<unsigned short>* dst,  // NOLINT
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<int>* dst,
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<unsigned int>* dst,
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<long>* dst,  // NOLINT
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text,
+                   std::vector<unsigned long>* dst,  // NOLINT
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text,
+                   std::vector<long long>* dst,  // NOLINT
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text,
+                   std::vector<unsigned long long>* dst,  // NOLINT
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<absl::int128>* dst,
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<absl::uint128>* dst,
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<float>* dst,
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+bool AbslParseFlag(absl::string_view text, std::vector<double>* dst,
+                   std::string* err) {
+  return ParseFlagVectorImpl(text, dst, err);
+}
+
 // --------------------------------------------------------------------
 // AbslUnparseFlag specializations for various builtin flag types.
 
@@ -200,6 +278,43 @@
 std::string AbslUnparseFlag(const std::vector<std::string>& v) {
   return absl::StrJoin(v, ",");
 }
+std::string AbslUnparseFlag(const std::vector<short>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<unsigned short>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<int>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<unsigned int>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<long>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<unsigned long>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<long long>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(  // NOLINT
+    const std::vector<unsigned long long>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<absl::int128>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<absl::uint128>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<float>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
+std::string AbslUnparseFlag(const std::vector<double>& v) {  // NOLINT
+  return UnparseFlagVectorImpl(v);
+}
 
 }  // namespace flags_internal
 
diff --git a/absl/flags/marshalling.h b/absl/flags/marshalling.h
index 5e04d6a..4e6424b 100644
--- a/absl/flags/marshalling.h
+++ b/absl/flags/marshalling.h
@@ -29,17 +29,30 @@
 // * `uint32_t`
 // * `int64_t`
 // * `uint64_t`
+// * `absl::int128`
+// * `absl::uint128`
 // * `float`
 // * `double`
 // * `std::string`
+// * `std::vector<int16_t>`
+// * `std::vector<uint16_t>`
+// * `std::vector<int32_t>`
+// * `std::vector<uint32_t>`
+// * `std::vector<int64_t>`
+// * `std::vector<uint64_t>`
+// * `std::vector<absl::int128>`
+// * `std::vector<absl::uint128>`
+// * `std::vector<float>`
+// * `std::vector<double>`
 // * `std::vector<std::string>`
 // * `std::optional<T>`
 // * `absl::LogSeverity` (provided natively for layering reasons)
 //
-// Note that support for integral types is implemented using overloads for
-// variable-width fundamental types (`short`, `int`, `long`, etc.). However,
-// you should prefer the fixed-width integral types (`int32_t`, `uint64_t`,
-// etc.) we've noted above within flag definitions.
+// Note that support for integral types (and vectors of integral types) is
+// implemented using overloads for variable-width fundamental types (`short`,
+// `int`, `long`, etc.). However, you should prefer the fixed-width integral
+// types (`int32_t`, `uint64_t`, etc.) we've noted above within flag
+// definitions.
 //
 // In addition, several Abseil libraries provide their own custom support for
 // Abseil flags. Documentation for these formats is provided in the type's
@@ -66,6 +79,16 @@
 // below.)
 //
 // -----------------------------------------------------------------------------
+// Vector Flags
+// -----------------------------------------------------------------------------
+//
+// Supported `std::vector` flag types parse comma-separated lists of elements
+// (e.g. `--my_ints=1,2,3`), delegating each element to `absl::ParseFlag()`.
+// Passing an empty string (`--my_ints=` or `--my_ints=""`) produces an empty
+// vector. Specifying a vector flag multiple times on the command line
+// overwrites previous values rather than appending to them.
+//
+// -----------------------------------------------------------------------------
 // Optional Flags
 // -----------------------------------------------------------------------------
 //
@@ -236,6 +259,28 @@
 bool AbslParseFlag(absl::string_view, float*, std::string*);
 bool AbslParseFlag(absl::string_view, double*, std::string*);
 bool AbslParseFlag(absl::string_view, std::string*, std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<short>*,             // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<unsigned short>*,    // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<int>*, std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<unsigned int>*,
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<long>*,              // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<unsigned long>*,     // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<long long>*,         // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view,
+                   std::vector<unsigned long long>*,  // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<absl::int128>*,
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<absl::uint128>*,
+                   std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<float>*, std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<double>*, std::string*);
 bool AbslParseFlag(absl::string_view, std::vector<std::string>*, std::string*);
 
 template <typename T>
@@ -263,6 +308,18 @@
 // considerations as fundamental types. Naming these 'AbslUnparseFlag' means we
 // can avoid the need for additional specializations of Unparse (below).
 std::string AbslUnparseFlag(absl::string_view v);
+std::string AbslUnparseFlag(const std::vector<short>&);               // NOLINT
+std::string AbslUnparseFlag(const std::vector<unsigned short>&);      // NOLINT
+std::string AbslUnparseFlag(const std::vector<int>&);                 // NOLINT
+std::string AbslUnparseFlag(const std::vector<unsigned int>&);        // NOLINT
+std::string AbslUnparseFlag(const std::vector<long>&);                // NOLINT
+std::string AbslUnparseFlag(const std::vector<unsigned long>&);       // NOLINT
+std::string AbslUnparseFlag(const std::vector<long long>&);           // NOLINT
+std::string AbslUnparseFlag(const std::vector<unsigned long long>&);  // NOLINT
+std::string AbslUnparseFlag(const std::vector<absl::int128>&);        // NOLINT
+std::string AbslUnparseFlag(const std::vector<absl::uint128>&);       // NOLINT
+std::string AbslUnparseFlag(const std::vector<float>&);               // NOLINT
+std::string AbslUnparseFlag(const std::vector<double>&);              // NOLINT
 std::string AbslUnparseFlag(const std::vector<std::string>&);
 
 template <typename T>
diff --git a/absl/flags/marshalling_test.cc b/absl/flags/marshalling_test.cc
index 6870920..77dd37a 100644
--- a/absl/flags/marshalling_test.cc
+++ b/absl/flags/marshalling_test.cc
@@ -15,6 +15,7 @@
 
 #include "absl/flags/marshalling.h"
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ -777,6 +778,178 @@
 
 // --------------------------------------------------------------------
 
+template <typename IntType>
+void TestIntegralVectorParsingCommon() {
+  std::string err;
+  std::vector<IntType> value = {IntType{99}, IntType{100}};
+
+  // Empty string clears pre-populated vector.
+  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
+  EXPECT_EQ(value, std::vector<IntType>{});
+
+  // Single and multiple values overwrite existing contents.
+  value = {IntType{99}};
+  EXPECT_TRUE(absl::ParseFlag("42", &value, &err));
+  EXPECT_EQ(value, std::vector<IntType>({IntType{42}}));
+
+  EXPECT_TRUE(absl::ParseFlag("1,0,+3,123", &value, &err));
+  EXPECT_EQ(value, (std::vector<IntType>{IntType{1}, IntType{0}, IntType{3},
+                                         IntType{123}}));
+
+  // Leading zeros are decimal (base 10), not octal; 0x/0X is hexadecimal.
+  EXPECT_TRUE(absl::ParseFlag("010,000100,0x10,0X20,+0x31", &value, &err));
+  EXPECT_EQ(value, (std::vector<IntType>{IntType{10}, IntType{100}, IntType{16},
+                                         IntType{32}, IntType{49}}));
+
+  // Surrounding ASCII whitespace around elements is stripped.
+  EXPECT_TRUE(absl::ParseFlag(" 10 ,  20,30  ,\t0x22\n", &value, &err));
+  EXPECT_EQ(value, (std::vector<IntType>{IntType{10}, IntType{20}, IntType{30},
+                                         IntType{34}}));
+
+  // Whitespace-only non-empty strings, empty tokens, internal whitespace, and
+  // malformed tokens are rejected.
+  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("   ", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("\r", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag(",", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag(",,", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,,2", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1, ,2", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag(",1", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,2,", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1 2,3", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,typo,3", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,2U,3", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,FFF,3", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,--2,3", &value, &err));
+}
+
+template <typename SignedIntType>
+void TestSignedIntegralVectorParsing() {
+  TestIntegralVectorParsingCommon<SignedIntType>();
+
+  std::string err;
+  std::vector<SignedIntType> value;
+  EXPECT_TRUE(absl::ParseFlag("-1,-010,-0x10", &value, &err));
+  EXPECT_EQ(value, (std::vector<SignedIntType>{
+                       SignedIntType{-1}, SignedIntType{-10},
+                       SignedIntType{-16}}));
+}
+
+template <typename UnsignedIntType>
+void TestUnsignedIntegralVectorParsing() {
+  TestIntegralVectorParsingCommon<UnsignedIntType>();
+
+  std::string err;
+  std::vector<UnsignedIntType> value;
+  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1,-2,3", &value, &err));
+}
+
+TEST(MarshallingTest, TestVectorOfIntegralTypesParsing) {
+  // Fundamental integral types.
+  TestSignedIntegralVectorParsing<short>();                 // NOLINT
+  TestUnsignedIntegralVectorParsing<unsigned short>();      // NOLINT
+  TestSignedIntegralVectorParsing<int>();
+  TestUnsignedIntegralVectorParsing<unsigned int>();
+  TestSignedIntegralVectorParsing<long>();                  // NOLINT
+  TestUnsignedIntegralVectorParsing<unsigned long>();       // NOLINT
+  TestSignedIntegralVectorParsing<long long>();             // NOLINT
+  TestUnsignedIntegralVectorParsing<unsigned long long>();  // NOLINT
+  TestSignedIntegralVectorParsing<absl::int128>();
+  TestUnsignedIntegralVectorParsing<absl::uint128>();
+
+  // Fixed-width and platform typedefs.
+  TestSignedIntegralVectorParsing<int16_t>();
+  TestUnsignedIntegralVectorParsing<uint16_t>();
+  TestSignedIntegralVectorParsing<int32_t>();
+  TestUnsignedIntegralVectorParsing<uint32_t>();
+  TestSignedIntegralVectorParsing<int64_t>();
+  TestUnsignedIntegralVectorParsing<uint64_t>();
+  TestUnsignedIntegralVectorParsing<size_t>();
+
+  // Range bounds checks.
+  std::string err;
+  std::vector<int16_t> i16;
+  EXPECT_TRUE(absl::ParseFlag("-32768,32767", &i16, &err));
+  EXPECT_EQ(i16, (std::vector<int16_t>{-32768, 32767}));
+  EXPECT_FALSE(absl::ParseFlag("1,40000", &i16, &err));
+  EXPECT_FALSE(absl::ParseFlag("-40000,1", &i16, &err));
+
+  std::vector<uint16_t> u16;
+  EXPECT_TRUE(absl::ParseFlag("0,65535", &u16, &err));
+  EXPECT_EQ(u16, (std::vector<uint16_t>{0, 65535}));
+  EXPECT_FALSE(absl::ParseFlag("1,70000", &u16, &err));
+
+  std::vector<int64_t> i64;
+  EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &i64, &err));
+
+  std::vector<uint64_t> u64;
+  EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &u64, &err));
+
+  std::vector<absl::int128> i128;
+  EXPECT_TRUE(absl::ParseFlag(
+      "-0x10000000000000000,0xFFF0FFFFFFFFFFFFFFF", &i128, &err));
+  EXPECT_EQ(
+      i128,
+      (std::vector<absl::int128>{
+          absl::MakeInt128(-1, 0),
+          absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF)}));
+
+  std::vector<absl::uint128> u128;
+  EXPECT_TRUE(absl::ParseFlag("0,0xFFF0FFFFFFFFFFFFFFF", &u128, &err));
+  EXPECT_EQ(
+      u128,
+      (std::vector<absl::uint128>{
+          0, absl::MakeUint128(0x000000000000fff, 0xFFFFFFFFFFFFFFF)}));
+}
+
+// --------------------------------------------------------------------
+
+template <typename FloatType>
+void TestFloatingPointVectorParsing() {
+  std::string err;
+  std::vector<FloatType> value = {FloatType{99}};
+
+  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
+  EXPECT_EQ(value, std::vector<FloatType>{});
+
+  value = {FloatType{99}};
+  EXPECT_TRUE(absl::ParseFlag("0.5, -1.25e-2, +0.25, 0x10p1", &value, &err));
+  ASSERT_EQ(value.size(), 4u);
+  EXPECT_EQ(value[0], static_cast<FloatType>(0.5));
+  EXPECT_EQ(value[1], static_cast<FloatType>(-0.0125));
+  EXPECT_EQ(value[2], static_cast<FloatType>(0.25));
+  EXPECT_EQ(value[3], static_cast<FloatType>(32.0));
+
+  EXPECT_TRUE(absl::ParseFlag("inf, -inf, NaN", &value, &err));
+  ASSERT_EQ(value.size(), 3u);
+  EXPECT_TRUE(std::isinf(value[0]) && value[0] > 0);
+  EXPECT_TRUE(std::isinf(value[1]) && value[1] < 0);
+  EXPECT_TRUE(std::isnan(value[2]));
+
+  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("   ", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag(",", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1.0,,2.0", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1.0, ,2.0", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag(",1.0", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1.0,2.0,", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1.0 2.0", &value, &err));
+  EXPECT_FALSE(absl::ParseFlag("1.0,bad,2.0", &value, &err));
+}
+
+TEST(MarshallingTest, TestVectorOfFloatingPointTypesParsing) {
+  TestFloatingPointVectorParsing<float>();
+  TestFloatingPointVectorParsing<double>();
+}
+
+// --------------------------------------------------------------------
+
 TEST(MarshallingTest, TestOptionalBoolParsing) {
   std::string err;
   std::optional<bool> value;
@@ -1060,6 +1233,61 @@
 
 // --------------------------------------------------------------------
 
+TEST(MarshallingTest, TestVectorUnparsing) {
+  EXPECT_EQ(absl::UnparseFlag(std::vector<std::string>{}), "");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<std::string>{"a", "b", "c"}),
+            "a,b,c");
+
+  EXPECT_EQ(absl::UnparseFlag(std::vector<short>{}), "");  // NOLINT
+  EXPECT_EQ(absl::UnparseFlag(std::vector<short>{-1, 0, 2}),  // NOLINT
+            "-1,0,2");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned short>{}), "");  // NOLINT
+  EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned short>{0, 1, 2}),  // NOLINT
+            "0,1,2");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<int>{}), "");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<int>{-10, 0, 20}), "-10,0,20");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned int>{}), "");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned int>{10, 20}), "10,20");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<long>{}), "");  // NOLINT
+  EXPECT_EQ(absl::UnparseFlag(std::vector<long>{-100, 200}),  // NOLINT
+            "-100,200");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned long>{}), "");  // NOLINT
+  EXPECT_EQ(absl::UnparseFlag(std::vector<unsigned long>{100, 200}),  // NOLINT
+            "100,200");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<long long>{}), "");  // NOLINT
+  EXPECT_EQ(absl::UnparseFlag(std::vector<long long>{-1000, 2000}),  // NOLINT
+            "-1000,2000");
+  EXPECT_EQ(
+      absl::UnparseFlag(std::vector<unsigned long long>{}),  // NOLINT
+      "");
+  EXPECT_EQ(
+      absl::UnparseFlag(std::vector<unsigned long long>{1000, 2000}),  // NOLINT
+      "1000,2000");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<absl::int128>{}), "");
+  EXPECT_EQ(
+      absl::UnparseFlag(
+          std::vector<absl::int128>{-1, absl::MakeInt128(-1, 0)}),
+      "-1,-18446744073709551616");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<absl::uint128>{}), "");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<absl::uint128>{
+                0, absl::MakeUint128(0, 0xFFFFFFFFFFFFFFFF)}),
+            "0,18446744073709551615");
+
+  EXPECT_EQ(absl::UnparseFlag(std::vector<float>{}), "");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<float>{
+                1.1f, -0.0f, std::numeric_limits<float>::infinity(),
+                -std::numeric_limits<float>::infinity(), std::nanf("")}),
+            "1.1,-0,inf,-inf,nan");
+
+  EXPECT_EQ(absl::UnparseFlag(std::vector<double>{}), "");
+  EXPECT_EQ(absl::UnparseFlag(std::vector<double>{
+                1.1, -0.0, std::numeric_limits<double>::infinity(),
+                -std::numeric_limits<double>::infinity(), std::nan("")}),
+            "1.1,-0,inf,-inf,nan");
+}
+
+// --------------------------------------------------------------------
+
 TEST(MarshallingTest, TestOptionalBoolUnparsing) {
   std::optional<bool> value;
 
@@ -1247,4 +1475,23 @@
   TestRoundtrip(std::numeric_limits<double>::denorm_min());
 }
 
+TEST(MarshallingTest, TestVectorNumericRoundTrip) {
+  TestRoundtrip(std::vector<int64_t>{});
+  TestRoundtrip(std::vector<int64_t>{
+      std::numeric_limits<int64_t>::min(), -1, 0, 1,
+      std::numeric_limits<int64_t>::max()});
+  TestRoundtrip(std::vector<float>{});
+  TestRoundtrip(std::vector<float>{
+      0.12345678f, 0.12345678e20f, 0.12345678e-20f,
+      std::numeric_limits<float>::min(), std::numeric_limits<float>::max(),
+      std::numeric_limits<float>::lowest(),
+      std::numeric_limits<float>::denorm_min()});
+  TestRoundtrip(std::vector<double>{});
+  TestRoundtrip(std::vector<double>{
+      0.12345678912345678, 0.12345678912345678e50, 0.12345678912345678e-50,
+      std::numeric_limits<double>::min(), std::numeric_limits<double>::max(),
+      std::numeric_limits<double>::lowest(),
+      std::numeric_limits<double>::denorm_min()});
+}
+
 }  // namespace
diff --git a/absl/flags/parse_test.cc b/absl/flags/parse_test.cc
index 9687950..a135c8c 100644
--- a/absl/flags/parse_test.cc
+++ b/absl/flags/parse_test.cc
@@ -15,8 +15,10 @@
 
 #include "absl/flags/parse.h"
 
+#include <stdint.h>
 #include <stdlib.h>
 
+#include <cmath>
 #include <fstream>
 #include <iostream>
 #include <string>
@@ -229,6 +231,10 @@
 ABSL_FLAG(double, double_flag, 1.1, "");
 ABSL_FLAG(std::string, string_flag, "a", "");
 ABSL_FLAG(bool, bool_flag, false, "");
+ABSL_FLAG(std::vector<int64_t>, int64_vec_flag,
+          std::vector<int64_t>({1, 2}), "");
+ABSL_FLAG(std::vector<double>, double_vec_flag,
+          std::vector<double>({0.5, 1.5}), "");
 ABSL_FLAG(UDT, udt_flag, -1, "");
 ABSL_RETIRED_FLAG(int, legacy_int, 1, "");
 ABSL_RETIRED_FLAG(bool, legacy_bool, false, "");
@@ -1213,4 +1219,98 @@
       testing::ExitedWithCode(0), "");
 }
 
+// --------------------------------------------------------------------
+
+TEST_F(ParseTest, TestValidNumericVectorArg) {
+  EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag),
+            (std::vector<int64_t>{1, 2}));
+  EXPECT_EQ(absl::GetFlag(FLAGS_double_vec_flag),
+            (std::vector<double>{0.5, 1.5}));
+
+  // Overwrites non-empty default, honors hex and leading-zero decimal.
+  const char* in_args1[] = {
+      "testbin",
+      "--int64_vec_flag=10,-20,0x10,010",
+      "--double_vec_flag=0.25, -1.25e-2, inf",
+  };
+  InvokeParse(in_args1);
+  EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag),
+            (std::vector<int64_t>{10, -20, 16, 10}));
+  const std::vector<double> dvec = absl::GetFlag(FLAGS_double_vec_flag);
+  ASSERT_EQ(dvec.size(), 3u);
+  EXPECT_DOUBLE_EQ(dvec[0], 0.25);
+  EXPECT_DOUBLE_EQ(dvec[1], -0.0125);
+  EXPECT_TRUE(std::isinf(dvec[2]) && dvec[2] > 0);
+
+  // Empty value clears vector to {}.
+  const char* in_args2[] = {
+      "testbin",
+      "--int64_vec_flag=",
+      "--double_vec_flag",
+      "",
+  };
+  InvokeParse(in_args2);
+  EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), std::vector<int64_t>{});
+  EXPECT_EQ(absl::GetFlag(FLAGS_double_vec_flag), std::vector<double>{});
+
+  // Repeated flags overwrite previous values rather than appending.
+  const char* in_args3[] = {
+      "testbin",
+      "--int64_vec_flag=1, 2",
+      "--int64_vec_flag=3",
+  };
+  InvokeParse(in_args3);
+  EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag), std::vector<int64_t>{3});
+
+  // Flagfile with surrounding whitespace and CRLF line endings.
+  std::string flagfile_flag;
+  constexpr const char* const vec_ff_data[] = {
+      "  --int64_vec_flag=7, 8, 9  ",
+  };
+  const char* in_args4[] = {
+      "testbin",
+      GetFlagfileFlag(
+          {{"parse_test.vec_ff", absl::MakeConstSpan(vec_ff_data)}},
+          flagfile_flag, "\r\n"),
+  };
+  InvokeParse(in_args4);
+  EXPECT_EQ(absl::GetFlag(FLAGS_int64_vec_flag),
+            (std::vector<int64_t>{7, 8, 9}));
+}
+
+TEST_F(ParseDeathTest, TestInvalidNumericVectorArg) {
+  const char* in_args1[] = {"testbin", "--int64_vec_flag=   "};
+  EXPECT_DEATH_IF_SUPPORTED(
+      InvokeParse(in_args1),
+      "Illegal value '   ' specified for flag 'int64_vec_flag'");
+
+  const char* in_args2[] = {"testbin", "--int64_vec_flag=1,,2"};
+  EXPECT_DEATH_IF_SUPPORTED(
+      InvokeParse(in_args2),
+      "Illegal value '1,,2' specified for flag 'int64_vec_flag'");
+
+  const char* in_args3[] = {"testbin", "--int64_vec_flag=1,2,"};
+  EXPECT_DEATH_IF_SUPPORTED(
+      InvokeParse(in_args3),
+      "Illegal value '1,2,' specified for flag 'int64_vec_flag'");
+
+  const char* in_args4[] = {"testbin", "--int64_vec_flag=1, ,2"};
+  EXPECT_DEATH_IF_SUPPORTED(
+      InvokeParse(in_args4),
+      "Illegal value '1, ,2' specified for flag 'int64_vec_flag'");
+
+  const char* in_args5[] = {"testbin", "--int64_vec_flag=1,typo,3"};
+  EXPECT_DEATH_IF_SUPPORTED(
+      InvokeParse(in_args5),
+      "Illegal value '1,typo,3' specified for flag 'int64_vec_flag'");
+
+  const char* in_args_check_ok[] = {"testbin", "--only_check_args",
+                                    "--int64_vec_flag=1,2,3"};
+  EXPECT_EXIT(InvokeParse(in_args_check_ok), testing::ExitedWithCode(0), "");
+
+  const char* in_args_check_bad[] = {"testbin", "--only_check_args",
+                                     "--int64_vec_flag=1,typo,3"};
+  EXPECT_EXIT(InvokeParse(in_args_check_bad), testing::ExitedWithCode(1), "");
+}
+
 }  // namespace