Reduce the per-flag code size of ABSL_FLAG default value generators.

Previously, every non-arithmetic `ABSL_FLAG` emitted its own `AbslFlagDefaultGenFor<name>::Gen` function. Because its address is stored in the flag, identical code folding could not merge duplicate generators, and each body materialized a temporary wrapper struct, copy- or move-constructed the flag value from its member, and destroyed the temporary.

`absl::flags_internal::DefaultArg` now selects the cheapest representation for a flag's default value:
* Arithmetic `constexpr` defaults continue to be stored inline (`kOneWord`).
* Empty defaults (`{}`, `std::nullopt`, and empty `std::string` literals or views) share a single `GenDefaultValue<T>` function per type, with `std::string` and `std::vector<std::string>` explicitly instantiated in `flag.cc`.
* Remaining per-flag `Gen` functions construct `Type` directly in place via `InitDefaultValue`, avoiding intermediate temporaries and exception landing pads when converting class types from literals or `const char*`.

Placing the generated `AbslFlagHelpGenFor<name>` and `AbslFlagDefaultGenFor<name>` structs in an unnamed namespace also allows applying `ABSL_INTERNAL_UNIQUE_SMALL_NAME()` to the remaining per-flag helper functions.

PiperOrigin-RevId: 1008379642
diff --git a/absl/flags/flag.h b/absl/flags/flag.h
index 2e9a9e6..d5f40a0 100644
--- a/absl/flags/flag.h
+++ b/absl/flags/flag.h
@@ -232,33 +232,52 @@
 // between the two via the call to HelpArg in absl::Flag instantiation below.
 // If help message expression is constexpr evaluable compiler will optimize
 // away this whole struct.
-// TODO(rogeeff): place these generated structs into local namespace and apply
-// ABSL_INTERNAL_UNIQUE_SHORT_NAME.
 // TODO(rogeeff): Apply __attribute__((nodebug)) to FLAGS_help_storage_##name
 #define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt)                       \
+  namespace {                                                                \
   struct AbslFlagHelpGenFor##name {                                          \
     /* The expression is run in the caller as part of the   */               \
     /* default value argument. That keeps temporaries alive */               \
     /* long enough for NonConst to work correctly.          */               \
     static constexpr absl::string_view Value(                                \
-        absl::string_view absl_flag_help ABSL_ATTRIBUTE_LIFETIME_BOUND  =     \
+        absl::string_view absl_flag_help ABSL_ATTRIBUTE_LIFETIME_BOUND =     \
             ABSL_FLAG_IMPL_FLAGHELP(txt)) {                                  \
       return absl_flag_help;                                                 \
     }                                                                        \
-    static std::string NonConst() { return std::string(Value()); }           \
+    static std::string NonConst() ABSL_INTERNAL_UNIQUE_SMALL_NAME() {        \
+      return std::string(Value());                                           \
+    }                                                                        \
   };                                                                         \
+  }                                                                          \
   constexpr auto FLAGS_help_storage_##name ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
       ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold) =                     \
           absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>( \
               0);
 
-#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)     \
-  struct AbslFlagDefaultGenFor##name {                                        \
-    Type value = absl::flags_internal::InitDefaultValue<Type>(default_value); \
-    static void Gen(void* absl_flag_default_loc) {                            \
-      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
-    }                                                                         \
-  };
+// Wraps default_value for compile-time inspection and in-place construction.
+#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value) \
+  namespace {                                                             \
+  struct AbslFlagDefaultGenFor##name {                                    \
+    template <typename U = Type>                                          \
+    static constexpr U MakeDefault() {                                    \
+      return absl::flags_internal::InitDefaultValue<U>(default_value);    \
+    }                                                                     \
+    Type value = MakeDefault();                                           \
+    template <typename U = Type>                                          \
+    static constexpr bool IsEmpty() {                                     \
+      return absl::flags_internal::IsEmptyDefault<U>(default_value, 0);   \
+    }                                                                     \
+    static void Gen(void* absl_flag_default_loc)                          \
+        ABSL_INTERNAL_UNIQUE_SMALL_NAME() {                               \
+      if constexpr (std::is_move_constructible_v<Type>) {                 \
+        new (absl_flag_default_loc) Type(MakeDefault());                  \
+      } else {                                                            \
+        new (absl_flag_default_loc)                                       \
+            Type(AbslFlagDefaultGenFor##name{}.value);                    \
+      }                                                                   \
+    }                                                                     \
+  };                                                                      \
+  }
 
 // ABSL_FLAG_IMPL
 //
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc
index 5cacf64..d9466e1 100644
--- a/absl/flags/flag_test.cc
+++ b/absl/flags/flag_test.cc
@@ -1397,3 +1397,107 @@
 #endif
 
 }  // namespace
+
+// --------------------------------------------------------------------
+
+namespace {
+
+constexpr char kLongLiteral[] = "a string longer than the small string buffer";
+const char* RuntimeCString() { return "runtime c string"; }
+
+struct AggregateUDT {
+  int value = 0;
+};
+bool AbslParseFlag(absl::string_view text, AggregateUDT* f, std::string*) {
+  return absl::SimpleAtoi(text, &f->value);
+}
+std::string AbslUnparseFlag(const AggregateUDT& f) {
+  return absl::StrCat(f.value);
+}
+
+}  // namespace
+
+ABSL_FLAG(std::string, test_dflt_string_literal, kLongLiteral, "");
+ABSL_FLAG(std::string, test_dflt_embedded_nul, "ab\0cd", "");
+ABSL_FLAG(std::string, test_dflt_runtime_cstring, RuntimeCString(), "");
+ABSL_FLAG(std::vector<std::string>, test_dflt_empty_vector, {}, "");
+ABSL_FLAG(std::vector<std::string>, test_dflt_nonempty_vector,
+          std::vector<std::string>({"a", "b"}), "");
+ABSL_FLAG(AggregateUDT, test_dflt_aggregate_braces, {7}, "");
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+ABSL_FLAG(AggregateUDT, test_dflt_designated_init, {.value = 9}, "");
+#endif
+
+namespace {
+
+TEST_F(FlagTest, TestConvertedAndAggregateDefaultValues) {
+  // Converting InitDefaultValue preserves NUL-termination and DefaultValue().
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_string_literal), kLongLiteral);
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_embedded_nul), "ab");
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_runtime_cstring), "runtime c string");
+
+  absl::SetFlag(&FLAGS_test_dflt_string_literal, "changed");
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_string_literal), "changed");
+  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_dflt_string_literal)
+                .DefaultValue(),
+            kLongLiteral);
+
+  // Non-empty braced and designated initializers are not treated as empty.
+  EXPECT_TRUE(absl::GetFlag(FLAGS_test_dflt_empty_vector).empty());
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_nonempty_vector),
+            std::vector<std::string>({"a", "b"}));
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_aggregate_braces).value, 7);
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+  EXPECT_EQ(absl::GetFlag(FLAGS_test_dflt_designated_init).value, 9);
+#endif
+}
+
+template <typename Gen, typename T = decltype(Gen::value)>
+constexpr bool UsesOneWordDefault() {
+  return flags::DefaultArg<T, Gen>(0).kind == flags::FlagDefaultKind::kOneWord;
+}
+
+template <typename Gen, typename T = decltype(Gen::value)>
+constexpr bool UsesSharedDefaultGen() {
+  constexpr flags::FlagDefaultArg arg = flags::DefaultArg<T, Gen>(0);
+  return arg.kind == flags::FlagDefaultKind::kGenFunc &&
+         arg.source.gen_func == &flags::GenDefaultValue<T>;
+}
+
+template <typename Gen, typename T = decltype(Gen::value)>
+constexpr bool UsesPerFlagDefaultGen() {
+  constexpr flags::FlagDefaultArg arg = flags::DefaultArg<T, Gen>(0);
+  return arg.kind == flags::FlagDefaultKind::kGenFunc &&
+         arg.source.gen_func == &Gen::Gen;
+}
+
+TEST_F(FlagTest, TestDefaultArgSelection) {
+  // Constexpr arithmetic -> kOneWord; runtime arithmetic -> per-flag Gen.
+  EXPECT_TRUE(UsesOneWordDefault<AbslFlagDefaultGenFortest_flag_02>());
+  EXPECT_TRUE(UsesPerFlagDefaultGen<
+              AbslFlagDefaultGenFortest_int_flag_with_non_const_default>());
+
+  // Empty defaults ("", {}, std::nullopt) -> shared GenDefaultValue<T>.
+  EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenFortest_flag_11>());
+  EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenFortest_flag_eb_05>());
+  EXPECT_TRUE(
+      UsesSharedDefaultGen<AbslFlagDefaultGenFortest_dflt_empty_vector>());
+  EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenFortest_flag_eb_06>());
+  EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenForoptional_int>());
+  EXPECT_TRUE(UsesSharedDefaultGen<AbslFlagDefaultGenForoptional_string>());
+
+  // Non-empty or runtime defaults -> per-flag Gen.
+  EXPECT_TRUE(
+      UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_string_literal>());
+  EXPECT_TRUE(
+      UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_runtime_cstring>());
+  EXPECT_TRUE(UsesPerFlagDefaultGen<
+              AbslFlagDefaultGenFortest_string_flag_with_non_const_default>());
+  EXPECT_TRUE(
+      UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_nonempty_vector>());
+  EXPECT_TRUE(
+      UsesPerFlagDefaultGen<AbslFlagDefaultGenFortest_dflt_aggregate_braces>());
+  EXPECT_TRUE(UsesPerFlagDefaultGen<AbslFlagDefaultGenForoptional_double>());
+}
+
+}  // namespace
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index 662b342..32861f7 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -56,6 +56,9 @@
 // if ABSL_FLAGS_STRIP_HELP is set to 1 before including absl/flags/flag.h
 const char kStrippedFlagHelp[] = "\001\002\003\004 (unknown) \004\003\002\001";
 
+template void GenDefaultValue<std::string>(void*);
+template void GenDefaultValue<std::vector<std::string>>(void*);
+
 namespace {
 
 // Currently we only validate flag values for user-defined flag types.
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index 8baff43..d400fb3 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -21,11 +21,14 @@
 
 #include <atomic>
 #include <cstring>
+#include <initializer_list>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
+#include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/base/call_once.h"
@@ -283,6 +286,80 @@
   return T{};
 }
 
+// True if class T is implicitly constructible from U (other than T itself).
+template <typename T, typename U>
+constexpr bool CanConvertToClassDefault() {
+  return std::is_class_v<T> && !std::is_same_v<std::decay_t<U>, T> &&
+         std::is_convertible_v<const U&, T>;
+}
+
+// Constructs class T directly from U via copy elision.
+template <typename T, typename U,
+          std::enable_if_t<CanConvertToClassDefault<T, U>(), int> = 0>
+constexpr T InitDefaultValue(const U& value) {
+  return value;
+}
+
+template <typename T>
+struct IsOptional : std::false_type {};
+template <typename T>
+struct IsOptional<std::optional<T>> : std::true_type {};
+
+template <typename T, typename U>
+constexpr bool IsStringWithStringViewDefault() {
+  return std::is_same_v<T, std::string> &&
+         std::is_convertible_v<const U&, absl::string_view>;
+}
+
+template <typename T, typename U>
+constexpr bool IsOptionalWithNulloptDefault() {
+  return IsOptional<T>::value &&
+         std::is_same_v<std::decay_t<U>, std::nullopt_t>;
+}
+
+// True if the default value expression is statically known to equal T{}.
+template <typename T>
+constexpr bool IsEmptyDefault(EmptyBraces, int) {
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool IsEmptyDefault(std::initializer_list<U>, int) {
+  return false;
+}
+
+template <typename T, typename U>
+constexpr bool IsEmptyDefault([[maybe_unused]] const U& v, int) {
+  if constexpr (IsStringWithStringViewDefault<T, U>()) {
+    return absl::string_view(v).empty();
+  } else {
+    return IsOptionalWithNulloptDefault<T, U>();
+  }
+}
+
+// Fallback for C++20 designated initializers like {.a = 1}.
+template <typename T, std::enable_if_t<std::is_class_v<T>, int> = 0>
+constexpr bool IsEmptyDefault(const T&, char) {
+  return false;
+}
+
+// Shared placement-new generator for flags with default T{}.
+template <typename T>
+void GenDefaultValue(void* dst) {
+  new (dst) T{};
+}
+
+extern template void GenDefaultValue<std::string>(void*);
+extern template void GenDefaultValue<std::vector<std::string>>(void*);
+
+// Requires copyability so non-copyable types still fail in GenT::Gen.
+template <typename ValueT, typename GenT>
+constexpr bool CanUseSharedDefaultGen() {
+  return std::is_default_constructible_v<ValueT> &&
+         std::is_copy_constructible_v<ValueT> && GenT::IsEmpty();
+}
+
+// Ranked int -> char -> ...: inline kOneWord, shared GenDefaultValue, or Gen.
 template <typename ValueT, typename GenT,
           std::enable_if_t<std::is_arithmetic_v<ValueT>, int> = ((void)GenT{},
                                                                  0)>
@@ -290,8 +367,14 @@
   return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
 }
 
-template <typename ValueT, typename GenT>
+template <typename ValueT, typename GenT,
+          std::enable_if_t<CanUseSharedDefaultGen<ValueT, GenT>(), int> = 0>
 constexpr FlagDefaultArg DefaultArg(char) {
+  return {FlagDefaultSrc(&GenDefaultValue<ValueT>), FlagDefaultKind::kGenFunc};
+}
+
+template <typename ValueT, typename GenT>
+constexpr FlagDefaultArg DefaultArg(...) {
   return {FlagDefaultSrc(&GenT::Gen), FlagDefaultKind::kGenFunc};
 }