about summary refs log tree commit diff
diff options
context:
space:
mode:
authorAbseil Team <absl-team@google.com>2020-03-26T15·48-0700
committerXiaoyi Zhang <zhangxy@google.com>2020-03-26T15·51-0400
commit79e0dc11514df035a8d07a356f9ee1800fb2160c (patch)
tree3e345e19f1cc496e127ec00dcebb67d7a311c3b5
parent132d791b40b0f99464e033bc624cfeac7aa68894 (diff)
Export of internal Abseil changes
--
990253454819ce26ff1dda9ab4bbc145b61d01e4 by Xiaoyi Zhang <zhangxy@google.com>:

Import github PR https://github.com/abseil/abseil-cpp/pull/645

PiperOrigin-RevId: 303119797

--
5ac845cb7929b7d1eaf59a309afd811db5001175 by Abseil Team <absl-team@google.com>:

Fix internal exception spec compatibility error

PiperOrigin-RevId: 303104081

--
3290595dd866eecab3c7044e2e3ca0adb74f1bf5 by Gennadiy Rozental <rogeeff@google.com>:

Use FlagValue<T> to represent the value of a flag. Place it directly after
FlagImpl and use a computed offset refer to it.

The offset is computed based on the assumption that the `value_` data member
is placed directly after the impl_ data member in Flag<T>.

This change will allow us to migrate to `T`-specific storage in the generic case.

This change decreases the overhead for int flags by 32 bytes.

PiperOrigin-RevId: 303038099

--
f2b37722cd7a6d3a60ef9713f0d2bbff56f3ddbf by Derek Mauro <dmauro@google.com>:

Minor correctness fix for an ABSL_HAVE_BUILTIN conditional

PiperOrigin-RevId: 302980666

--
39c079a6141ae1c5728af8bf33a39c8aff9deb9f by Abseil Team <absl-team@google.com>:

Use ABSL_HARDENING_ASSERT in b-tree and SwissTable iterators.

PiperOrigin-RevId: 302970075

--
9668a044e080c789df32bcaa1ffb5100831cd9fa by Benjamin Barenblat <bbaren@google.com>:

Correct `add_subdirectory` line in CMake googletest support

Commit bcefbdcdf6ad85046ccacee0aeffba5404d3e528 added support for building with CMake against a local googletest checkout, but I missed a line when constructing the diff. Change the `add_subdirectory` line to reference the correct directories.

PiperOrigin-RevId: 302947488

--
0a3c10fabf80a43ca69ab8b1570030e55f2be741 by Andy Soffer <asoffer@google.com>:

Remove unused distribution format traits.

PiperOrigin-RevId: 302896176

--
0478f2f6270e5ed64c0e28ec09556ca90b2d46a9 by Samuel Benzaquen <sbenza@google.com>:

Fix for CWG:2310.

PiperOrigin-RevId: 302734089

--
3cb978dda5cae5905affdc0914dcc2d27671ed11 by Samuel Benzaquen <sbenza@google.com>:

Fix the Allocate/Deallocate functions to use the same underlying allocator type.

PiperOrigin-RevId: 302721804

--
ae38d3984fb68b4e3ddc165fa8d5c24d5936be52 by Matthew Brown <matthewbr@google.com>:

Internal Change

PiperOrigin-RevId: 302717314

--
7357cf7abd03cc60b6e82b5f28a8e34935c3b4dc by Andy Getzendanner <durandal@google.com>:

Fix typo: s/ABSL_HARDENED_ASSERT/ABSL_HARDENING_ASSERT/

PiperOrigin-RevId: 302532164
GitOrigin-RevId: 990253454819ce26ff1dda9ab4bbc145b61d01e4
Change-Id: Ie595a221c16e1e7e1255ad42e029b646c5f3e11d
-rw-r--r--CMake/Googletest/DownloadGTest.cmake4
-rw-r--r--absl/base/macros.h7
-rw-r--r--absl/container/internal/btree.h11
-rw-r--r--absl/container/internal/common.h3
-rw-r--r--absl/container/internal/container_memory.h7
-rw-r--r--absl/container/internal/container_memory_test.cc38
-rw-r--r--absl/container/internal/raw_hash_set.h5
-rw-r--r--absl/flags/flag_test.cc24
-rw-r--r--absl/flags/internal/flag.cc82
-rw-r--r--absl/flags/internal/flag.h259
-rw-r--r--absl/random/BUILD.bazel5
-rw-r--r--absl/random/CMakeLists.txt3
-rw-r--r--absl/random/bit_gen_ref.h5
-rw-r--r--absl/random/distribution_format_traits.h278
-rw-r--r--absl/random/distributions.h37
-rw-r--r--absl/random/internal/distribution_caller.h15
-rw-r--r--absl/random/internal/mocking_bit_gen_base.h39
-rw-r--r--absl/random/mocking_bit_gen.cc30
-rw-r--r--absl/random/mocking_bit_gen.h8
-rw-r--r--absl/strings/BUILD.bazel1
-rw-r--r--absl/strings/CMakeLists.txt1
-rw-r--r--absl/strings/internal/str_format/arg.cc52
-rw-r--r--absl/strings/internal/str_format/arg.h16
-rw-r--r--absl/strings/internal/str_format/bind.cc2
-rw-r--r--absl/strings/internal/str_format/checker_test.cc10
-rw-r--r--absl/strings/internal/str_format/float_conversion.cc41
-rw-r--r--absl/strings/internal/str_format/parser_test.cc2
-rw-r--r--absl/strings/numbers_test.cc1
-rw-r--r--absl/strings/str_format_test.cc8
29 files changed, 387 insertions, 607 deletions
diff --git a/CMake/Googletest/DownloadGTest.cmake b/CMake/Googletest/DownloadGTest.cmake
index 6552e1da1dc4..9d071c917011 100644
--- a/CMake/Googletest/DownloadGTest.cmake
+++ b/CMake/Googletest/DownloadGTest.cmake
@@ -38,6 +38,4 @@ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 
 # Add googletest directly to our build. This defines the gtest and gtest_main
 # targets.
-add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src
-                 ${CMAKE_BINARY_DIR}/googletest-build
-                 EXCLUDE_FROM_ALL)
+add_subdirectory(${absl_gtest_src_dir} ${absl_gtest_build_dir} EXCLUDE_FROM_ALL)
diff --git a/absl/base/macros.h b/absl/base/macros.h
index 2f6089f4c683..2c4e3570cd55 100644
--- a/absl/base/macros.h
+++ b/absl/base/macros.h
@@ -212,7 +212,8 @@ ABSL_NAMESPACE_END
 // aborts the program in release mode (when NDEBUG is defined). The
 // implementation should abort the program as quickly as possible and ideally it
 // should not be possible to ignore the abort request.
-#if ABSL_HAVE_BUILTIN(__builtin_trap) || \
+#if (ABSL_HAVE_BUILTIN(__builtin_trap) &&         \
+     ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
     (defined(__GNUC__) && !defined(__clang__))
 #define ABSL_INTERNAL_HARDENING_ABORT() \
   do {                                  \
@@ -225,11 +226,11 @@ ABSL_NAMESPACE_END
 
 // ABSL_HARDENING_ASSERT()
 //
-// `ABSL_HARDENED_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
+// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
 // runtime assertions that should be enabled in hardened builds even when
 // `NDEBUG` is defined.
 //
-// When `NDEBUG` is not defined, `ABSL_HARDENED_ASSERT()` is identical to
+// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
 // `ABSL_ASSERT()`.
 //
 // See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
diff --git a/absl/container/internal/btree.h b/absl/container/internal/btree.h
index adf49f81c571..4504e9ce6659 100644
--- a/absl/container/internal/btree.h
+++ b/absl/container/internal/btree.h
@@ -937,8 +937,13 @@ struct btree_iterator {
   }
 
   // Accessors for the key/value the iterator is pointing at.
-  reference operator*() const { return node->value(position); }
-  pointer operator->() const { return &node->value(position); }
+  reference operator*() const {
+    ABSL_HARDENING_ASSERT(node != nullptr);
+    ABSL_HARDENING_ASSERT(node->start() <= position);
+    ABSL_HARDENING_ASSERT(node->finish() > position);
+    return node->value(position);
+  }
+  pointer operator->() const { return &operator*(); }
 
   btree_iterator &operator++() {
     increment();
@@ -1769,6 +1774,7 @@ void btree_iterator<N, R, P>::increment_slow() {
       position = node->position();
       node = node->parent();
     }
+    // TODO(ezb): assert we aren't incrementing end() instead of handling.
     if (position == node->finish()) {
       *this = save;
     }
@@ -1792,6 +1798,7 @@ void btree_iterator<N, R, P>::decrement_slow() {
       position = node->position() - 1;
       node = node->parent();
     }
+    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
     if (position < node->start()) {
       *this = save;
     }
diff --git a/absl/container/internal/common.h b/absl/container/internal/common.h
index 5037d80316cc..8990f2947273 100644
--- a/absl/container/internal/common.h
+++ b/absl/container/internal/common.h
@@ -138,6 +138,7 @@ class node_handle<Policy, PolicyTraits, Alloc,
                   absl::void_t<typename Policy::mapped_type>>
     : public node_handle_base<PolicyTraits, Alloc> {
   using Base = node_handle_base<PolicyTraits, Alloc>;
+  using slot_type = typename PolicyTraits::slot_type;
 
  public:
   using key_type = typename Policy::key_type;
@@ -145,7 +146,7 @@ class node_handle<Policy, PolicyTraits, Alloc,
 
   constexpr node_handle() {}
 
-  auto key() const -> decltype(PolicyTraits::key(this->slot())) {
+  auto key() const -> decltype(PolicyTraits::key(std::declval<slot_type*>())) {
     return PolicyTraits::key(this->slot());
   }
 
diff --git a/absl/container/internal/container_memory.h b/absl/container/internal/container_memory.h
index d24b0f841384..55b59c7ff313 100644
--- a/absl/container/internal/container_memory.h
+++ b/absl/container/internal/container_memory.h
@@ -37,6 +37,9 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
+template <size_t Alignment>
+struct alignas(Alignment) AlignedType {};
+
 // Allocates at least n bytes aligned to the specified alignment.
 // Alignment must be a power of 2. It must be positive.
 //
@@ -48,7 +51,7 @@ template <size_t Alignment, class Alloc>
 void* Allocate(Alloc* alloc, size_t n) {
   static_assert(Alignment > 0, "");
   assert(n && "n must be positive");
-  struct alignas(Alignment) M {};
+  using M = AlignedType<Alignment>;
   using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   A mem_alloc(*alloc);
@@ -64,7 +67,7 @@ template <size_t Alignment, class Alloc>
 void Deallocate(Alloc* alloc, void* p, size_t n) {
   static_assert(Alignment > 0, "");
   assert(n && "n must be positive");
-  struct alignas(Alignment) M {};
+  using M = AlignedType<Alignment>;
   using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   A mem_alloc(*alloc);
diff --git a/absl/container/internal/container_memory_test.cc b/absl/container/internal/container_memory_test.cc
index 7942c7be4831..e3262e3c884a 100644
--- a/absl/container/internal/container_memory_test.cc
+++ b/absl/container/internal/container_memory_test.cc
@@ -16,6 +16,8 @@
 
 #include <cstdint>
 #include <tuple>
+#include <typeindex>
+#include <typeinfo>
 #include <utility>
 
 #include "gmock/gmock.h"
@@ -27,6 +29,9 @@ ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace {
 
+using ::testing::Gt;
+using ::testing::_;
+using ::testing::ElementsAre;
 using ::testing::Pair;
 
 TEST(Memory, AlignmentLargerThanBase) {
@@ -45,6 +50,39 @@ TEST(Memory, AlignmentSmallerThanBase) {
   Deallocate<2>(&alloc, mem, 3);
 }
 
+std::map<std::type_index, int>& AllocationMap() {
+  static auto* map = new std::map<std::type_index, int>;
+  return *map;
+}
+
+template <typename T>
+struct TypeCountingAllocator {
+  TypeCountingAllocator() = default;
+  template <typename U>
+  TypeCountingAllocator(const TypeCountingAllocator<U>&) {}  // NOLINT
+
+  using value_type = T;
+
+  T* allocate(size_t n, const void* = nullptr) {
+    AllocationMap()[typeid(T)] += n;
+    return std::allocator<T>().allocate(n);
+  }
+  void deallocate(T* p, std::size_t n) {
+    AllocationMap()[typeid(T)] -= n;
+    return std::allocator<T>().deallocate(p, n);
+  }
+};
+
+TEST(Memory, AllocateDeallocateMatchType) {
+  TypeCountingAllocator<int> alloc;
+  void* mem = Allocate<1>(&alloc, 1);
+  // Verify that it was allocated
+  EXPECT_THAT(AllocationMap(), ElementsAre(Pair(_, Gt(0))));
+  Deallocate<1>(&alloc, mem, 1);
+  // Verify that the deallocation matched.
+  EXPECT_THAT(AllocationMap(), ElementsAre(Pair(_, 0)));
+}
+
 class Fixture : public ::testing::Test {
   using Alloc = std::allocator<std::string>;
 
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h
index fb47f62f4e7d..e47e1fedf725 100644
--- a/absl/container/internal/raw_hash_set.h
+++ b/absl/container/internal/raw_hash_set.h
@@ -104,6 +104,7 @@
 
 #include "absl/base/internal/bits.h"
 #include "absl/base/internal/endian.h"
+#include "absl/base/macros.h"
 #include "absl/base/port.h"
 #include "absl/container/internal/common.h"
 #include "absl/container/internal/compressed_tuple.h"
@@ -651,9 +652,9 @@ class raw_hash_set {
     iterator(ctrl_t* ctrl) : ctrl_(ctrl) {}  // for end()
     iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {}
 
-    void assert_is_full() const { assert(IsFull(*ctrl_)); }
+    void assert_is_full() const { ABSL_HARDENING_ASSERT(IsFull(*ctrl_)); }
     void assert_is_valid() const {
-      assert(!ctrl_ || IsFull(*ctrl_) || *ctrl_ == kSentinel);
+      ABSL_HARDENING_ASSERT(!ctrl_ || IsFull(*ctrl_) || *ctrl_ == kSentinel);
     }
 
     void skip_empty_or_deleted() {
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc
index 3a0255769527..377e3b2b89ad 100644
--- a/absl/flags/flag_test.cc
+++ b/absl/flags/flag_test.cc
@@ -91,30 +91,30 @@ struct S2 {
 };
 
 TEST_F(FlagTest, Traits) {
-  EXPECT_EQ(flags::FlagValue::Kind<int>(),
+  EXPECT_EQ(flags::StorageKind<int>(),
             flags::FlagValueStorageKind::kOneWordAtomic);
-  EXPECT_EQ(flags::FlagValue::Kind<bool>(),
+  EXPECT_EQ(flags::StorageKind<bool>(),
             flags::FlagValueStorageKind::kOneWordAtomic);
-  EXPECT_EQ(flags::FlagValue::Kind<double>(),
+  EXPECT_EQ(flags::StorageKind<double>(),
             flags::FlagValueStorageKind::kOneWordAtomic);
-  EXPECT_EQ(flags::FlagValue::Kind<int64_t>(),
+  EXPECT_EQ(flags::StorageKind<int64_t>(),
             flags::FlagValueStorageKind::kOneWordAtomic);
 
 #if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD)
-  EXPECT_EQ(flags::FlagValue::Kind<S1>(),
+  EXPECT_EQ(flags::StorageKind<S1>(),
             flags::FlagValueStorageKind::kTwoWordsAtomic);
-  EXPECT_EQ(flags::FlagValue::Kind<S2>(),
+  EXPECT_EQ(flags::StorageKind<S2>(),
             flags::FlagValueStorageKind::kTwoWordsAtomic);
 #else
-  EXPECT_EQ(flags::FlagValue::Kind<S1>(),
+  EXPECT_EQ(flags::StorageKind<S1>(),
             flags::FlagValueStorageKind::kHeapAllocated);
-  EXPECT_EQ(flags::FlagValue::Kind<S2>(),
+  EXPECT_EQ(flags::StorageKind<S2>(),
             flags::FlagValueStorageKind::kHeapAllocated);
 #endif
 
-  EXPECT_EQ(flags::FlagValue::Kind<std::string>(),
+  EXPECT_EQ(flags::StorageKind<std::string>(),
             flags::FlagValueStorageKind::kHeapAllocated);
-  EXPECT_EQ(flags::FlagValue::Kind<std::vector<std::string>>(),
+  EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(),
             flags::FlagValueStorageKind::kHeapAllocated);
 }
 
@@ -624,10 +624,10 @@ TEST_F(FlagTest, TestNonDefaultConstructibleType) {
   EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 25);
 }
 
-// --------------------------------------------------------------------
-
 }  // namespace
 
+// --------------------------------------------------------------------
+
 ABSL_RETIRED_FLAG(bool, old_bool_flag, true, "old descr");
 ABSL_RETIRED_FLAG(int, old_int_flag, (int)std::sqrt(10), "old descr");
 ABSL_RETIRED_FLAG(std::string, old_str_flag, "", absl::StrCat("old ", "descr"));
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index 56a5ed2bc468..5b4499abe47e 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -25,6 +25,7 @@
 #include <vector>
 
 #include "absl/base/attributes.h"
+#include "absl/base/casts.h"
 #include "absl/base/config.h"
 #include "absl/base/const_init.h"
 #include "absl/base/optimization.h"
@@ -135,18 +136,18 @@ void FlagImpl::Init() {
       (*default_value_.gen_func)(), DynValueDeleter{op_});
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kHeapAllocated:
-      value_.dynamic = init_value.release();
+      HeapAllocatedValue() = init_value.release();
       break;
     case FlagValueStorageKind::kOneWordAtomic: {
       int64_t atomic_value;
-      std::memcpy(&atomic_value, init_value.get(), flags_internal::Sizeof(op_));
-      value_.one_word_atomic.store(atomic_value, std::memory_order_release);
+      std::memcpy(&atomic_value, init_value.get(), Sizeof(op_));
+      OneWordValue().store(atomic_value, std::memory_order_release);
       break;
     }
     case FlagValueStorageKind::kTwoWordsAtomic: {
       AlignedTwoWords atomic_value{0, 0};
-      std::memcpy(&atomic_value, init_value.get(), flags_internal::Sizeof(op_));
-      value_.two_words_atomic.store(atomic_value, std::memory_order_release);
+      std::memcpy(&atomic_value, init_value.get(), Sizeof(op_));
+      TwoWordsValue().store(atomic_value, std::memory_order_release);
       break;
     }
   }
@@ -198,18 +199,18 @@ std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
 void FlagImpl::StoreValue(const void* src) {
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kHeapAllocated:
-      flags_internal::Copy(op_, src, value_.dynamic);
+      Copy(op_, src, HeapAllocatedValue());
       break;
     case FlagValueStorageKind::kOneWordAtomic: {
-      int64_t one_word_val;
-      std::memcpy(&one_word_val, src, flags_internal::Sizeof(op_));
-      value_.one_word_atomic.store(one_word_val, std::memory_order_release);
+      int64_t one_word_val = 0;
+      std::memcpy(&one_word_val, src, Sizeof(op_));
+      OneWordValue().store(one_word_val, std::memory_order_release);
       break;
     }
     case FlagValueStorageKind::kTwoWordsAtomic: {
       AlignedTwoWords two_words_val{0, 0};
-      std::memcpy(&two_words_val, src, flags_internal::Sizeof(op_));
-      value_.two_words_atomic.store(two_words_val, std::memory_order_release);
+      std::memcpy(&two_words_val, src, Sizeof(op_));
+      TwoWordsValue().store(two_words_val, std::memory_order_release);
       break;
     }
   }
@@ -258,17 +259,19 @@ std::string FlagImpl::CurrentValue() const {
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kHeapAllocated: {
       absl::MutexLock l(guard);
-      return flags_internal::Unparse(op_, value_.dynamic);
+      return flags_internal::Unparse(op_, HeapAllocatedValue());
     }
     case FlagValueStorageKind::kOneWordAtomic: {
       const auto one_word_val =
-          value_.one_word_atomic.load(std::memory_order_acquire);
-      return flags_internal::Unparse(op_, &one_word_val);
+          absl::bit_cast<std::array<char, sizeof(int64_t)>>(
+              OneWordValue().load(std::memory_order_acquire));
+      return flags_internal::Unparse(op_, one_word_val.data());
     }
     case FlagValueStorageKind::kTwoWordsAtomic: {
       const auto two_words_val =
-          value_.two_words_atomic.load(std::memory_order_acquire);
-      return flags_internal::Unparse(op_, &two_words_val);
+          absl::bit_cast<std::array<char, sizeof(AlignedTwoWords)>>(
+              TwoWordsValue().load(std::memory_order_acquire));
+      return flags_internal::Unparse(op_, two_words_val.data());
     }
   }
 
@@ -317,18 +320,18 @@ std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kHeapAllocated: {
       return absl::make_unique<FlagState>(
-          this, flags_internal::Clone(op_, value_.dynamic), modified,
+          this, flags_internal::Clone(op_, HeapAllocatedValue()), modified,
           on_command_line, counter_);
     }
     case FlagValueStorageKind::kOneWordAtomic: {
       return absl::make_unique<FlagState>(
-          this, value_.one_word_atomic.load(std::memory_order_acquire),
-          modified, on_command_line, counter_);
+          this, OneWordValue().load(std::memory_order_acquire), modified,
+          on_command_line, counter_);
     }
     case FlagValueStorageKind::kTwoWordsAtomic: {
       return absl::make_unique<FlagState>(
-          this, value_.two_words_atomic.load(std::memory_order_acquire),
-          modified, on_command_line, counter_);
+          this, TwoWordsValue().load(std::memory_order_acquire), modified,
+          on_command_line, counter_);
     }
   }
   return nullptr;
@@ -359,6 +362,28 @@ bool FlagImpl::RestoreState(const FlagState& flag_state) {
   return true;
 }
 
+template <typename StorageT>
+typename StorageT::value_type& FlagImpl::OffsetValue() const {
+  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
+  // The offset is deduced via Flag value type specific op_.
+  size_t offset = flags_internal::ValueOffset(op_);
+
+  return reinterpret_cast<StorageT*>(p + offset)->value;
+}
+
+void*& FlagImpl::HeapAllocatedValue() const {
+  assert(ValueStorageKind() == FlagValueStorageKind::kHeapAllocated);
+  return OffsetValue<FlagHeapAllocatedValue>();
+}
+std::atomic<int64_t>& FlagImpl::OneWordValue() const {
+  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic);
+  return OffsetValue<FlagOneWordValue>();
+}
+std::atomic<AlignedTwoWords>& FlagImpl::TwoWordsValue() const {
+  assert(ValueStorageKind() == FlagValueStorageKind::kTwoWordsAtomic);
+  return OffsetValue<FlagTwoWordsValue>();
+}
+
 // Attempts to parse supplied `value` string using parsing routine in the `flag`
 // argument. If parsing successful, this function replaces the dst with newly
 // parsed value. In case if any error is encountered in either step, the error
@@ -383,20 +408,19 @@ void FlagImpl::Read(void* dst) const {
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kHeapAllocated: {
       absl::MutexLock l(guard);
-
-      flags_internal::CopyConstruct(op_, value_.dynamic, dst);
+      flags_internal::CopyConstruct(op_, HeapAllocatedValue(), dst);
       break;
     }
     case FlagValueStorageKind::kOneWordAtomic: {
-      const auto one_word_val =
-          value_.one_word_atomic.load(std::memory_order_acquire);
-      std::memcpy(dst, &one_word_val, flags_internal::Sizeof(op_));
+      const int64_t one_word_val =
+          OneWordValue().load(std::memory_order_acquire);
+      std::memcpy(dst, &one_word_val, Sizeof(op_));
       break;
     }
     case FlagValueStorageKind::kTwoWordsAtomic: {
-      const auto two_words_val =
-          value_.two_words_atomic.load(std::memory_order_acquire);
-      std::memcpy(dst, &two_words_val, flags_internal::Sizeof(op_));
+      const AlignedTwoWords two_words_val =
+          TwoWordsValue().load(std::memory_order_acquire);
+      std::memcpy(dst, &two_words_val, Sizeof(op_));
       break;
     }
   }
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index f27e558b25a4..19119bbb6193 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -53,56 +53,13 @@ enum class FlagOp {
   kStaticTypeId,
   kParse,
   kUnparse,
+  kValueOffset,
 };
 using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
 
-// Flag value specific operations routine.
+// Forward declaration for Flag value specific operations.
 template <typename T>
-void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
-  switch (op) {
-    case FlagOp::kDelete:
-      delete static_cast<const T*>(v1);
-      return nullptr;
-    case FlagOp::kClone:
-      return new T(*static_cast<const T*>(v1));
-    case FlagOp::kCopy:
-      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
-      return nullptr;
-    case FlagOp::kCopyConstruct:
-      new (v2) T(*static_cast<const T*>(v1));
-      return nullptr;
-    case FlagOp::kSizeof:
-      return reinterpret_cast<void*>(sizeof(T));
-    case FlagOp::kStaticTypeId: {
-      auto* static_id = &FlagStaticTypeIdGen<T>;
-
-      // Cast from function pointer to void* is not portable.
-      // We don't have an easy way to work around this, but it works fine
-      // on all the platforms we test and as long as size of pointers match
-      // we should be fine to do reinterpret cast.
-      static_assert(sizeof(void*) == sizeof(static_id),
-                    "Flag's static type id does not work on this platform");
-      return reinterpret_cast<void*>(static_id);
-    }
-    case FlagOp::kParse: {
-      // Initialize the temporary instance of type T based on current value in
-      // destination (which is going to be flag's default value).
-      T temp(*static_cast<T*>(v2));
-      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
-                              static_cast<std::string*>(v3))) {
-        return nullptr;
-      }
-      *static_cast<T*>(v2) = std::move(temp);
-      return v2;
-    }
-    case FlagOp::kUnparse:
-      *static_cast<std::string*>(v2) =
-          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
-      return nullptr;
-    default:
-      return nullptr;
-  }
-}
+void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3);
 
 // Deletes memory interpreting obj as flag value type pointer.
 inline void Delete(FlagOpFn op, const void* obj) {
@@ -144,6 +101,16 @@ inline FlagStaticTypeId StaticTypeId(FlagOpFn op) {
   return reinterpret_cast<FlagStaticTypeId>(
       op(FlagOp::kStaticTypeId, nullptr, nullptr, nullptr));
 }
+// Returns offset of the field value_ from the field impl_ inside of
+// absl::Flag<T> data. Given FlagImpl pointer p you can get the
+// location of the corresponding value as:
+//      reinterpret_cast<char*>(p) + ValueOffset().
+inline ptrdiff_t ValueOffset(FlagOpFn op) {
+  // This sequence of casts reverses the sequence from
+  // `flags_internal::FlagOps()`
+  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
+      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 // Flag help auxiliary structs.
@@ -239,6 +206,10 @@ using FlagUseOneWordStorage = std::integral_constant<
 struct alignas(16) AlignedTwoWords {
   int64_t first;
   int64_t second;
+
+  bool IsInitialized() const {
+    return first != flags_internal::UninitializedFlagValue();
+  }
 };
 
 template <typename T>
@@ -248,8 +219,14 @@ using FlagUseTwoWordsStorage = std::integral_constant<
 #else
 // This is actually unused and only here to avoid ifdefs in other palces.
 struct AlignedTwoWords {
-  constexpr AlignedTwoWords() = default;
-  constexpr AlignedTwoWords(int64_t, int64_t) {}
+  constexpr AlignedTwoWords() noexcept : dummy() {}
+  constexpr AlignedTwoWords(int64_t, int64_t) noexcept : dummy() {}
+  char dummy;
+
+  bool IsInitialized() const {
+    std::abort();
+    return true;
+  }
 };
 
 // This trait should be type dependent, otherwise SFINAE below will fail
@@ -269,23 +246,70 @@ enum class FlagValueStorageKind : uint8_t {
   kTwoWordsAtomic = 2
 };
 
-union FlagValue {
-  constexpr explicit FlagValue(int64_t v) : one_word_atomic(v) {}
+template <typename T>
+static constexpr FlagValueStorageKind StorageKind() {
+  return FlagUseHeapStorage<T>::value
+             ? FlagValueStorageKind::kHeapAllocated
+             : FlagUseOneWordStorage<T>::value
+                   ? FlagValueStorageKind::kOneWordAtomic
+                   : FlagUseTwoWordsStorage<T>::value
+                         ? FlagValueStorageKind::kTwoWordsAtomic
+                         : FlagValueStorageKind::kHeapAllocated;
+}
+
+struct FlagHeapAllocatedValue {
+  using value_type = void*;
+
+  value_type value;
+};
+
+struct FlagOneWordValue {
+  using value_type = std::atomic<int64_t>;
+  constexpr FlagOneWordValue() : value(UninitializedFlagValue()) {}
 
-  template <typename T>
-  static constexpr FlagValueStorageKind Kind() {
-    return FlagUseHeapStorage<T>::value
-               ? FlagValueStorageKind::kHeapAllocated
-               : FlagUseOneWordStorage<T>::value
-                     ? FlagValueStorageKind::kOneWordAtomic
-                     : FlagUseTwoWordsStorage<T>::value
-                           ? FlagValueStorageKind::kTwoWordsAtomic
-                           : FlagValueStorageKind::kHeapAllocated;
+  value_type value;
+};
+
+struct FlagTwoWordsValue {
+  using value_type = std::atomic<AlignedTwoWords>;
+  constexpr FlagTwoWordsValue()
+      : value(AlignedTwoWords{UninitializedFlagValue(), 0}) {}
+
+  value_type value;
+};
+
+template <typename T,
+          FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
+struct FlagValue;
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kHeapAllocated>
+    : FlagHeapAllocatedValue {
+  bool Get(T*) const { return false; }
+};
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
+  bool Get(T* dst) const {
+    int64_t one_word_val = value.load(std::memory_order_acquire);
+    if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
+      return false;
+    }
+    std::memcpy(dst, static_cast<const void*>(&one_word_val), sizeof(T));
+    return true;
   }
+};
 
-  void* dynamic;
-  std::atomic<int64_t> one_word_atomic;
-  std::atomic<flags_internal::AlignedTwoWords> two_words_atomic;
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kTwoWordsAtomic> : FlagTwoWordsValue {
+  bool Get(T* dst) const {
+    AlignedTwoWords two_words_val = value.load(std::memory_order_acquire);
+    if (ABSL_PREDICT_FALSE(!two_words_val.IsInitialized())) {
+      return false;
+    }
+    std::memcpy(dst, static_cast<const void*>(&two_words_val), sizeof(T));
+    return true;
+  }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -333,35 +357,10 @@ class FlagImpl final : public flags_internal::CommandLineFlag {
         counter_(0),
         callback_(nullptr),
         default_value_(default_value_gen),
-        value_(flags_internal::UninitializedFlagValue()),
         data_guard_{} {}
 
   // Constant access methods
   void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(*DataGuard());
-  template <typename T, typename std::enable_if<FlagUseHeapStorage<T>::value,
-                                                int>::type = 0>
-  void Get(T* dst) const {
-    Read(dst);
-  }
-  template <typename T, typename std::enable_if<FlagUseOneWordStorage<T>::value,
-                                                int>::type = 0>
-  void Get(T* dst) const {
-    int64_t one_word_val =
-        value_.one_word_atomic.load(std::memory_order_acquire);
-    if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
-      DataGuard();  // Make sure flag initialized
-      one_word_val = value_.one_word_atomic.load(std::memory_order_acquire);
-    }
-    std::memcpy(dst, static_cast<const void*>(&one_word_val), sizeof(T));
-  }
-  template <typename T, typename std::enable_if<
-                            FlagUseTwoWordsStorage<T>::value, int>::type = 0>
-  void Get(T* dst) const {
-    DataGuard();  // Make sure flag initialized
-    const auto two_words_val =
-        value_.two_words_atomic.load(std::memory_order_acquire);
-    std::memcpy(dst, &two_words_val, sizeof(T));
-  }
 
   // Mutating access methods
   void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
@@ -391,6 +390,25 @@ class FlagImpl final : public flags_internal::CommandLineFlag {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
   // Flag initialization called via absl::call_once.
   void Init();
+
+  // Offset value access methods. One per storage kind. These methods to not
+  // respect const correctness, so be very carefull using them.
+
+  // This is a shared helper routine which encapsulates most of the magic. Since
+  // it is only used inside the three routines below, which are defined in
+  // flag.cc, we can define it in that file as well.
+  template <typename StorageT>
+  typename StorageT::value_type& OffsetValue() const;
+  // This is an accessor for a value stored in heap allocated storage.
+  // Returns a mutable reference to a pointer to allow vlaue mutation.
+  void*& HeapAllocatedValue() const;
+  // This is an accessor for a value stored as one word atomic. Returns a
+  // mutable reference to an atomic value.
+  std::atomic<int64_t>& OneWordValue() const;
+  // This is an accessor for a value stored as two words atomic. Returns a
+  // mutable reference to an atomic value.
+  std::atomic<AlignedTwoWords>& TwoWordsValue() const;
+
   // Attempts to parse supplied `value` string. If parsing is successful,
   // returns new value. Otherwise returns nullptr.
   std::unique_ptr<void, DynValueDeleter> TryParse(absl::string_view value,
@@ -488,13 +506,6 @@ class FlagImpl final : public flags_internal::CommandLineFlag {
   // these two cases.
   FlagDefaultSrc default_value_;
 
-  // Atomically mutable flag's state
-
-  // Flag's value. This can be either the atomically stored small value or
-  // pointer to the heap allocated dynamic value. value_storage_kind_ is used
-  // to distinguish these cases.
-  FlagValue value_;
-
   // This is reserved space for an absl::Mutex to guard flag data. It will be
   // initialized in FlagImpl::Init via placement new.
   // We can't use "absl::Mutex data_guard_", since this class is not literal.
@@ -514,8 +525,9 @@ class Flag {
  public:
   constexpr Flag(const char* name, const char* filename, const FlagHelpArg help,
                  const FlagDfltGenFunc default_value_gen)
-      : impl_(name, filename, &FlagOps<T>, help, FlagValue::Kind<T>(),
-              default_value_gen) {}
+      : impl_(name, filename, &FlagOps<T>, help,
+              flags_internal::StorageKind<T>(), default_value_gen),
+        value_() {}
 
   T Get() const {
     // See implementation notes in CommandLineFlag::Get().
@@ -530,7 +542,7 @@ class Flag {
     impl_.AssertValidType(&flags_internal::FlagStaticTypeIdGen<T>);
 #endif
 
-    impl_.Get(&u.value);
+    if (!value_.Get(&u.value)) impl_.Read(&u.value);
     return std::move(u.value);
   }
   void Set(const T& v) {
@@ -556,10 +568,63 @@ class Flag {
  private:
   template <typename U, bool do_register>
   friend class FlagRegistrar;
+
   // Flag's data
+  // The implementation depends on value_ field to be placed exactly after the
+  // impl_ field, so that impl_ can figure out the offset to the value and
+  // access it.
   FlagImpl impl_;
+  FlagValue<T> value_;
 };
 
+///////////////////////////////////////////////////////////////////////////////
+// Implementation of Flag value specific operations routine.
+template <typename T>
+void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
+  switch (op) {
+    case FlagOp::kDelete:
+      delete static_cast<const T*>(v1);
+      return nullptr;
+    case FlagOp::kClone:
+      return new T(*static_cast<const T*>(v1));
+    case FlagOp::kCopy:
+      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
+      return nullptr;
+    case FlagOp::kCopyConstruct:
+      new (v2) T(*static_cast<const T*>(v1));
+      return nullptr;
+    case FlagOp::kSizeof:
+      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
+    case FlagOp::kStaticTypeId:
+      return reinterpret_cast<void*>(&FlagStaticTypeIdGen<T>);
+    case FlagOp::kParse: {
+      // Initialize the temporary instance of type T based on current value in
+      // destination (which is going to be flag's default value).
+      T temp(*static_cast<T*>(v2));
+      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
+                              static_cast<std::string*>(v3))) {
+        return nullptr;
+      }
+      *static_cast<T*>(v2) = std::move(temp);
+      return v2;
+    }
+    case FlagOp::kUnparse:
+      *static_cast<std::string*>(v2) =
+          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
+      return nullptr;
+    case FlagOp::kValueOffset: {
+      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
+      // offset of the data.
+      ptrdiff_t round_to = alignof(FlagValue<T>);
+      ptrdiff_t offset =
+          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
+      return reinterpret_cast<void*>(offset);
+    }
+  }
+  return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // This class facilitates Flag object registration and tail expression-based
 // flag definition, for example:
 // ABSL_FLAG(int, foo, 42, "Foo help").OnUpdate(NotifyFooWatcher);
diff --git a/absl/random/BUILD.bazel b/absl/random/BUILD.bazel
index f78fbc7eedb8..4d94e1ba4155 100644
--- a/absl/random/BUILD.bazel
+++ b/absl/random/BUILD.bazel
@@ -53,7 +53,6 @@ cc_library(
         "bernoulli_distribution.h",
         "beta_distribution.h",
         "discrete_distribution.h",
-        "distribution_format_traits.h",
         "distributions.h",
         "exponential_distribution.h",
         "gaussian_distribution.h",
@@ -141,16 +140,12 @@ cc_library(
 cc_library(
     name = "mocking_bit_gen",
     testonly = 1,
-    srcs = [
-        "mocking_bit_gen.cc",
-    ],
     hdrs = [
         "mocking_bit_gen.h",
     ],
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":distributions",
-        "//absl/base:raw_logging_internal",
         "//absl/container:flat_hash_map",
         "//absl/meta:type_traits",
         "//absl/random/internal:distribution_caller",
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index efa55d8fa73b..69bedbd6b0da 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -102,8 +102,6 @@ absl_cc_library(
   HDRS
     "mock_distributions.h"
     "mocking_bit_gen.h"
-  SRCS
-    "mocking_bit_gen.cc"
   COPTS
     ${ABSL_DEFAULT_COPTS}
   LINKOPTS
@@ -168,7 +166,6 @@ absl_cc_library(
     "bernoulli_distribution.h"
     "beta_distribution.h"
     "discrete_distribution.h"
-    "distribution_format_traits.h"
     "distributions.h"
     "exponential_distribution.h"
     "gaussian_distribution.h"
diff --git a/absl/random/bit_gen_ref.h b/absl/random/bit_gen_ref.h
index e8771162e5fb..59591a479d8c 100644
--- a/absl/random/bit_gen_ref.h
+++ b/absl/random/bit_gen_ref.h
@@ -132,7 +132,7 @@ namespace random_internal {
 
 template <>
 struct DistributionCaller<absl::BitGenRef> {
-  template <typename DistrT, typename FormatT, typename... Args>
+  template <typename DistrT, typename... Args>
   static typename DistrT::result_type Call(absl::BitGenRef* gen_ref,
                                            Args&&... args) {
     auto* mock_ptr = gen_ref->mocked_gen_ptr_;
@@ -140,8 +140,7 @@ struct DistributionCaller<absl::BitGenRef> {
       DistrT dist(std::forward<Args>(args)...);
       return dist(*gen_ref);
     } else {
-      return mock_ptr->template Call<DistrT, FormatT>(
-          std::forward<Args>(args)...);
+      return mock_ptr->template Call<DistrT>(std::forward<Args>(args)...);
     }
   }
 };
diff --git a/absl/random/distribution_format_traits.h b/absl/random/distribution_format_traits.h
deleted file mode 100644
index 22b358cc8c37..000000000000
--- a/absl/random/distribution_format_traits.h
+++ /dev/null
@@ -1,278 +0,0 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#ifndef ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
-#define ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
-
-#include <string>
-#include <tuple>
-#include <typeinfo>
-
-#include "absl/meta/type_traits.h"
-#include "absl/random/bernoulli_distribution.h"
-#include "absl/random/beta_distribution.h"
-#include "absl/random/exponential_distribution.h"
-#include "absl/random/gaussian_distribution.h"
-#include "absl/random/log_uniform_int_distribution.h"
-#include "absl/random/poisson_distribution.h"
-#include "absl/random/uniform_int_distribution.h"
-#include "absl/random/uniform_real_distribution.h"
-#include "absl/random/zipf_distribution.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-struct IntervalClosedClosedTag;
-struct IntervalClosedOpenTag;
-struct IntervalOpenClosedTag;
-struct IntervalOpenOpenTag;
-
-namespace random_internal {
-
-// ScalarTypeName defines a preferred hierarchy of preferred type names for
-// scalars, and is evaluated at compile time for the specific type
-// specialization.
-template <typename T>
-constexpr const char* ScalarTypeName() {
-  static_assert(std::is_integral<T>() || std::is_floating_point<T>(), "");
-  // clang-format off
-    return
-        std::is_same<T, float>::value ? "float" :
-        std::is_same<T, double>::value ? "double" :
-        std::is_same<T, long double>::value ? "long double" :
-        std::is_same<T, bool>::value ? "bool" :
-        std::is_signed<T>::value && sizeof(T) == 1 ? "int8_t" :
-        std::is_signed<T>::value && sizeof(T) == 2 ? "int16_t" :
-        std::is_signed<T>::value && sizeof(T) == 4 ? "int32_t" :
-        std::is_signed<T>::value && sizeof(T) == 8 ? "int64_t" :
-        std::is_unsigned<T>::value && sizeof(T) == 1 ? "uint8_t" :
-        std::is_unsigned<T>::value && sizeof(T) == 2 ? "uint16_t" :
-        std::is_unsigned<T>::value && sizeof(T) == 4 ? "uint32_t" :
-        std::is_unsigned<T>::value && sizeof(T) == 8 ? "uint64_t" :
-            "undefined";
-  // clang-format on
-
-  // NOTE: It would be nice to use typeid(T).name(), but that's an
-  // implementation-defined attribute which does not necessarily
-  // correspond to a name. We could potentially demangle it
-  // using, e.g. abi::__cxa_demangle.
-}
-
-// Distribution traits used by DistributionCaller and internal implementation
-// details of the mocking framework.
-/*
-struct DistributionFormatTraits {
-   // Returns the parameterized name of the distribution function.
-   static constexpr const char* FunctionName()
-   // Format DistrT parameters.
-   static std::string FormatArgs(DistrT& dist);
-   // Format DistrT::result_type results.
-   static std::string FormatResults(DistrT& dist);
-};
-*/
-template <typename DistrT>
-struct DistributionFormatTraits;
-
-template <typename R>
-struct DistributionFormatTraits<absl::uniform_int_distribution<R>> {
-  using distribution_t = absl::uniform_int_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Uniform"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat("absl::IntervalClosedClosed, ", (d.min)(), ", ",
-                        (d.max)());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::uniform_real_distribution<R>> {
-  using distribution_t = absl::uniform_real_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Uniform"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat((d.min)(), ", ", (d.max)());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::exponential_distribution<R>> {
-  using distribution_t = absl::exponential_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Exponential"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat(d.lambda());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::poisson_distribution<R>> {
-  using distribution_t = absl::poisson_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Poisson"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat(d.mean());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <>
-struct DistributionFormatTraits<absl::bernoulli_distribution> {
-  using distribution_t = absl::bernoulli_distribution;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Bernoulli"; }
-
-  static constexpr const char* FunctionName() { return Name(); }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat(d.p());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::beta_distribution<R>> {
-  using distribution_t = absl::beta_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Beta"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat(d.alpha(), ", ", d.beta());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::zipf_distribution<R>> {
-  using distribution_t = absl::zipf_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Zipf"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat(d.k(), ", ", d.v(), ", ", d.q());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::gaussian_distribution<R>> {
-  using distribution_t = absl::gaussian_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "Gaussian"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrJoin(std::make_tuple(d.mean(), d.stddev()), ", ");
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename R>
-struct DistributionFormatTraits<absl::log_uniform_int_distribution<R>> {
-  using distribution_t = absl::log_uniform_int_distribution<R>;
-  using result_t = typename distribution_t::result_type;
-
-  static constexpr const char* Name() { return "LogUniform"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrJoin(std::make_tuple((d.min)(), (d.max)(), d.base()), ", ");
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-template <typename NumType>
-struct UniformDistributionWrapper;
-
-template <typename NumType>
-struct DistributionFormatTraits<UniformDistributionWrapper<NumType>> {
-  using distribution_t = UniformDistributionWrapper<NumType>;
-  using result_t = NumType;
-
-  static constexpr const char* Name() { return "Uniform"; }
-
-  static std::string FunctionName() {
-    return absl::StrCat(Name(), "<", ScalarTypeName<NumType>(), ">");
-  }
-  static std::string FormatArgs(const distribution_t& d) {
-    return absl::StrCat((d.min)(), ", ", (d.max)());
-  }
-  static std::string FormatResults(absl::Span<const result_t> results) {
-    return absl::StrJoin(results, ", ");
-  }
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
diff --git a/absl/random/distributions.h b/absl/random/distributions.h
index d026d92b9045..8680f6a66f0a 100644
--- a/absl/random/distributions.h
+++ b/absl/random/distributions.h
@@ -55,7 +55,6 @@
 #include "absl/base/internal/inline_variable.h"
 #include "absl/random/bernoulli_distribution.h"
 #include "absl/random/beta_distribution.h"
-#include "absl/random/distribution_format_traits.h"
 #include "absl/random/exponential_distribution.h"
 #include "absl/random/gaussian_distribution.h"
 #include "absl/random/internal/distributions.h"  // IWYU pragma: export
@@ -126,14 +125,13 @@ Uniform(TagType tag,
         R lo, R hi) {
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = random_internal::UniformDistributionWrapper<R>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   auto a = random_internal::uniform_lower_bound(tag, lo, hi);
   auto b = random_internal::uniform_upper_bound(tag, lo, hi);
   if (a > b) return a;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, tag, lo, hi);
+      distribution_t>(&urbg, tag, lo, hi);
 }
 
 // absl::Uniform<T>(bitgen, lo, hi)
@@ -146,7 +144,6 @@ Uniform(URBG&& urbg,  // NOLINT(runtime/references)
         R lo, R hi) {
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = random_internal::UniformDistributionWrapper<R>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   constexpr auto tag = absl::IntervalClosedOpen;
   auto a = random_internal::uniform_lower_bound(tag, lo, hi);
@@ -154,7 +151,7 @@ Uniform(URBG&& urbg,  // NOLINT(runtime/references)
   if (a > b) return a;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, lo, hi);
+      distribution_t>(&urbg, lo, hi);
 }
 
 // absl::Uniform(tag, bitgen, lo, hi)
@@ -172,14 +169,13 @@ Uniform(TagType tag,
   using gen_t = absl::decay_t<URBG>;
   using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
   using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
   auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
   if (a > b) return a;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, tag, static_cast<return_t>(lo),
+      distribution_t>(&urbg, tag, static_cast<return_t>(lo),
                                 static_cast<return_t>(hi));
 }
 
@@ -196,7 +192,6 @@ Uniform(URBG&& urbg,  // NOLINT(runtime/references)
   using gen_t = absl::decay_t<URBG>;
   using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
   using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   constexpr auto tag = absl::IntervalClosedOpen;
   auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
@@ -204,7 +199,7 @@ Uniform(URBG&& urbg,  // NOLINT(runtime/references)
   if (a > b) return a;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, static_cast<return_t>(lo),
+      distribution_t>(&urbg, static_cast<return_t>(lo),
                                 static_cast<return_t>(hi));
 }
 
@@ -217,10 +212,9 @@ typename absl::enable_if_t<!std::is_signed<R>::value, R>  //
 Uniform(URBG&& urbg) {  // NOLINT(runtime/references)
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = random_internal::UniformDistributionWrapper<R>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg);
+      distribution_t>(&urbg);
 }
 
 // -----------------------------------------------------------------------------
@@ -248,10 +242,9 @@ bool Bernoulli(URBG&& urbg,  // NOLINT(runtime/references)
                double p) {
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = absl::bernoulli_distribution;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, p);
+      distribution_t>(&urbg, p);
 }
 
 // -----------------------------------------------------------------------------
@@ -281,10 +274,9 @@ RealType Beta(URBG&& urbg,  // NOLINT(runtime/references)
 
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = typename absl::beta_distribution<RealType>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, alpha, beta);
+      distribution_t>(&urbg, alpha, beta);
 }
 
 // -----------------------------------------------------------------------------
@@ -314,10 +306,9 @@ RealType Exponential(URBG&& urbg,  // NOLINT(runtime/references)
 
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = typename absl::exponential_distribution<RealType>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, lambda);
+      distribution_t>(&urbg, lambda);
 }
 
 // -----------------------------------------------------------------------------
@@ -346,10 +337,9 @@ RealType Gaussian(URBG&& urbg,  // NOLINT(runtime/references)
 
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = typename absl::gaussian_distribution<RealType>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, mean, stddev);
+      distribution_t>(&urbg, mean, stddev);
 }
 
 // -----------------------------------------------------------------------------
@@ -389,10 +379,9 @@ IntType LogUniform(URBG&& urbg,  // NOLINT(runtime/references)
 
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = typename absl::log_uniform_int_distribution<IntType>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, lo, hi, base);
+      distribution_t>(&urbg, lo, hi, base);
 }
 
 // -----------------------------------------------------------------------------
@@ -420,10 +409,9 @@ IntType Poisson(URBG&& urbg,  // NOLINT(runtime/references)
 
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = typename absl::poisson_distribution<IntType>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, mean);
+      distribution_t>(&urbg, mean);
 }
 
 // -----------------------------------------------------------------------------
@@ -453,10 +441,9 @@ IntType Zipf(URBG&& urbg,  // NOLINT(runtime/references)
 
   using gen_t = absl::decay_t<URBG>;
   using distribution_t = typename absl::zipf_distribution<IntType>;
-  using format_t = random_internal::DistributionFormatTraits<distribution_t>;
 
   return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t, format_t>(&urbg, hi, q, v);
+      distribution_t>(&urbg, hi, q, v);
 }
 
 ABSL_NAMESPACE_END
diff --git a/absl/random/internal/distribution_caller.h b/absl/random/internal/distribution_caller.h
index 02603cf84355..4e0724440cbc 100644
--- a/absl/random/internal/distribution_caller.h
+++ b/absl/random/internal/distribution_caller.h
@@ -33,20 +33,7 @@ struct DistributionCaller {
   // Call the provided distribution type. The parameters are expected
   // to be explicitly specified.
   // DistrT is the distribution type.
-  // FormatT is the formatter type:
-  //
-  // struct FormatT {
-  //   using result_type = distribution_t::result_type;
-  //   static std::string FormatCall(
-  //       const distribution_t& distr,
-  //       absl::Span<const result_type>);
-  //
-  //   static std::string FormatExpectation(
-  //       absl::string_view match_args,
-  //       absl::Span<const result_t> results);
-  // }
-  //
-  template <typename DistrT, typename FormatT, typename... Args>
+  template <typename DistrT, typename... Args>
   static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
     DistrT dist(std::forward<Args>(args)...);
     return dist(*urbg);
diff --git a/absl/random/internal/mocking_bit_gen_base.h b/absl/random/internal/mocking_bit_gen_base.h
index eeeae9d295b2..23ecaf6c7e63 100644
--- a/absl/random/internal/mocking_bit_gen_base.h
+++ b/absl/random/internal/mocking_bit_gen_base.h
@@ -16,8 +16,6 @@
 #ifndef ABSL_RANDOM_INTERNAL_MOCKING_BIT_GEN_BASE_H_
 #define ABSL_RANDOM_INTERNAL_MOCKING_BIT_GEN_BASE_H_
 
-#include <atomic>
-#include <deque>
 #include <string>
 #include <typeinfo>
 
@@ -28,27 +26,6 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// MockingBitGenExpectationFormatter is invoked to format unsatisfied mocks
-// and remaining results into a description string.
-template <typename DistrT, typename FormatT>
-struct MockingBitGenExpectationFormatter {
-  std::string operator()(absl::string_view args) {
-    return absl::StrCat(FormatT::FunctionName(), "(", args, ")");
-  }
-};
-
-// MockingBitGenCallFormatter is invoked to format each distribution call
-// into a description string for the mock log.
-template <typename DistrT, typename FormatT>
-struct MockingBitGenCallFormatter {
-  std::string operator()(const DistrT& dist,
-                         const typename DistrT::result_type& result) {
-    return absl::StrCat(
-        FormatT::FunctionName(), "(", FormatT::FormatArgs(dist), ") => {",
-        FormatT::FormatResults(absl::MakeSpan(&result, 1)), "}");
-  }
-};
-
 class MockingBitGenBase {
   template <typename>
   friend struct DistributionCaller;
@@ -61,14 +38,9 @@ class MockingBitGenBase {
   static constexpr result_type(max)() { return (generator_type::max)(); }
   result_type operator()() { return gen_(); }
 
-  MockingBitGenBase() : gen_(), observed_call_log_() {}
   virtual ~MockingBitGenBase() = default;
 
  protected:
-  const std::deque<std::string>& observed_call_log() {
-    return observed_call_log_;
-  }
-
   // CallImpl is the type-erased virtual dispatch.
   // The type of dist is always distribution<T>,
   // The type of result is always distribution<T>::result_type.
@@ -81,10 +53,9 @@ class MockingBitGenBase {
   }
 
   // Call the generating distribution function.
-  // Invoked by DistributionCaller<>::Call<DistT, FormatT>.
+  // Invoked by DistributionCaller<>::Call<DistT>.
   // DistT is the distribution type.
-  // FormatT is the distribution formatter traits type.
-  template <typename DistrT, typename FormatT, typename... Args>
+  template <typename DistrT, typename... Args>
   typename DistrT::result_type Call(Args&&... args) {
     using distr_result_type = typename DistrT::result_type;
     using ArgTupleT = std::tuple<absl::decay_t<Args>...>;
@@ -100,17 +71,11 @@ class MockingBitGenBase {
       result = dist(gen_);
     }
 
-    // TODO(asoffer): Forwarding the args through means we no longer need to
-    // extract them from the from the distribution in formatter traits. We can
-    // just StrJoin them.
-    observed_call_log_.push_back(
-        MockingBitGenCallFormatter<DistrT, FormatT>{}(dist, result));
     return result;
   }
 
  private:
   generator_type gen_;
-  std::deque<std::string> observed_call_log_;
 };  // namespace random_internal
 
 }  // namespace random_internal
diff --git a/absl/random/mocking_bit_gen.cc b/absl/random/mocking_bit_gen.cc
deleted file mode 100644
index 6bb1e414aeab..000000000000
--- a/absl/random/mocking_bit_gen.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#include "absl/random/mocking_bit_gen.h"
-
-#include <string>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-MockingBitGen::~MockingBitGen() {
-
-  for (const auto& del : deleters_) {
-    del();
-  }
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
diff --git a/absl/random/mocking_bit_gen.h b/absl/random/mocking_bit_gen.h
index 36cef91113e3..3d8a979e734f 100644
--- a/absl/random/mocking_bit_gen.h
+++ b/absl/random/mocking_bit_gen.h
@@ -100,7 +100,9 @@ class MockingBitGen : public absl::random_internal::MockingBitGenBase {
  public:
   MockingBitGen() {}
 
-  ~MockingBitGen() override;
+  ~MockingBitGen() override {
+    for (const auto& del : deleters_) del();
+  }
 
  private:
   template <typename DistrT, typename... Args>
@@ -182,10 +184,10 @@ namespace random_internal {
 
 template <>
 struct DistributionCaller<absl::MockingBitGen> {
-  template <typename DistrT, typename FormatT, typename... Args>
+  template <typename DistrT, typename... Args>
   static typename DistrT::result_type Call(absl::MockingBitGen* gen,
                                            Args&&... args) {
-    return gen->template Call<DistrT, FormatT>(std::forward<Args>(args)...);
+    return gen->template Call<DistrT>(std::forward<Args>(args)...);
   }
 };
 
diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel
index e72db82c02aa..64f55fb4f93d 100644
--- a/absl/strings/BUILD.bazel
+++ b/absl/strings/BUILD.bazel
@@ -485,6 +485,7 @@ cc_test(
     copts = ABSL_TEST_COPTS,
     visibility = ["//visibility:private"],
     deps = [
+        ":internal",
         ":pow10_helper",
         ":strings",
         "//absl/base:config",
diff --git a/absl/strings/CMakeLists.txt b/absl/strings/CMakeLists.txt
index 668d722b3cee..c7874ecf10da 100644
--- a/absl/strings/CMakeLists.txt
+++ b/absl/strings/CMakeLists.txt
@@ -284,6 +284,7 @@ absl_cc_test(
     absl::raw_logging_internal
     absl::random_random
     absl::random_distributions
+    absl::strings_internal
     gmock_main
 )
 
diff --git a/absl/strings/internal/str_format/arg.cc b/absl/strings/internal/str_format/arg.cc
index 4d0604e00c4b..3aa0296bf212 100644
--- a/absl/strings/internal/str_format/arg.cc
+++ b/absl/strings/internal/str_format/arg.cc
@@ -120,24 +120,25 @@ class ConvertedIntInfo {
 // the '#' flag is specified to modify the precision for 'o' conversions.
 string_view BaseIndicator(const ConvertedIntInfo &info,
                           const ConversionSpec conv) {
-  bool alt = conv.flags().alt;
-  int radix = FormatConversionCharRadix(conv.conv());
-  if (conv.conv() == ConversionChar::p) alt = true;  // always show 0x for %p.
+  bool alt = conv.has_alt_flag();
+  int radix = FormatConversionCharRadix(conv.conversion_char());
+  if (conv.conversion_char() == ConversionChar::p)
+    alt = true;  // always show 0x for %p.
   // From the POSIX description of '#' flag:
   //   "For x or X conversion specifiers, a non-zero result shall have
   //   0x (or 0X) prefixed to it."
   if (alt && radix == 16 && !info.digits().empty()) {
-    if (FormatConversionCharIsUpper(conv.conv())) return "0X";
+    if (FormatConversionCharIsUpper(conv.conversion_char())) return "0X";
     return "0x";
   }
   return {};
 }
 
 string_view SignColumn(bool neg, const ConversionSpec conv) {
-  if (FormatConversionCharIsSigned(conv.conv())) {
+  if (FormatConversionCharIsSigned(conv.conversion_char())) {
     if (neg) return "-";
-    if (conv.flags().show_pos) return "+";
-    if (conv.flags().sign_col) return " ";
+    if (conv.has_show_pos_flag()) return "+";
+    if (conv.has_sign_col_flag()) return " ";
   }
   return {};
 }
@@ -147,9 +148,9 @@ bool ConvertCharImpl(unsigned char v, const ConversionSpec conv,
   size_t fill = 0;
   if (conv.width() >= 0) fill = conv.width();
   ReducePadding(1, &fill);
-  if (!conv.flags().left) sink->Append(fill, ' ');
+  if (!conv.has_left_flag()) sink->Append(fill, ' ');
   sink->Append(1, v);
-  if (conv.flags().left) sink->Append(fill, ' ');
+  if (conv.has_left_flag()) sink->Append(fill, ' ');
   return true;
 }
 
@@ -174,7 +175,7 @@ bool ConvertIntImplInner(const ConvertedIntInfo &info,
   if (!precision_specified)
     precision = 1;
 
-  if (conv.flags().alt && conv.conv() == ConversionChar::o) {
+  if (conv.has_alt_flag() && conv.conversion_char() == ConversionChar::o) {
     // From POSIX description of the '#' (alt) flag:
     //   "For o conversion, it increases the precision (if necessary) to
     //   force the first digit of the result to be zero."
@@ -187,13 +188,13 @@ bool ConvertIntImplInner(const ConvertedIntInfo &info,
   size_t num_zeroes = Excess(formatted.size(), precision);
   ReducePadding(num_zeroes, &fill);
 
-  size_t num_left_spaces = !conv.flags().left ? fill : 0;
-  size_t num_right_spaces = conv.flags().left ? fill : 0;
+  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
+  size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
 
   // From POSIX description of the '0' (zero) flag:
   //   "For d, i, o, u, x, and X conversion specifiers, if a precision
   //   is specified, the '0' flag is ignored."
-  if (!precision_specified && conv.flags().zero) {
+  if (!precision_specified && conv.has_zero_flag()) {
     num_zeroes += num_left_spaces;
     num_left_spaces = 0;
   }
@@ -209,8 +210,8 @@ bool ConvertIntImplInner(const ConvertedIntInfo &info,
 
 template <typename T>
 bool ConvertIntImplInner(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
-  ConvertedIntInfo info(v, conv.conv());
-  if (conv.flags().basic && (conv.conv() != ConversionChar::p)) {
+  ConvertedIntInfo info(v, conv.conversion_char());
+  if (conv.is_basic() && (conv.conversion_char() != ConversionChar::p)) {
     if (info.is_neg()) sink->Append(1, '-');
     if (info.digits().empty()) {
       sink->Append(1, '0');
@@ -224,13 +225,14 @@ bool ConvertIntImplInner(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
 
 template <typename T>
 bool ConvertIntArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
-  if (FormatConversionCharIsFloat(conv.conv())) {
+  if (FormatConversionCharIsFloat(conv.conversion_char())) {
     return FormatConvertImpl(static_cast<double>(v), conv, sink).value;
   }
-  if (conv.conv() == ConversionChar::c)
+  if (conv.conversion_char() == ConversionChar::c)
     return ConvertCharImpl(static_cast<unsigned char>(v), conv, sink);
-  if (!FormatConversionCharIsIntegral(conv.conv())) return false;
-  if (!FormatConversionCharIsSigned(conv.conv()) && IsSigned<T>::value) {
+  if (!FormatConversionCharIsIntegral(conv.conversion_char())) return false;
+  if (!FormatConversionCharIsSigned(conv.conversion_char()) &&
+      IsSigned<T>::value) {
     using U = typename MakeUnsigned<T>::type;
     return FormatConvertImpl(static_cast<U>(v), conv, sink).value;
   }
@@ -239,19 +241,19 @@ bool ConvertIntArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
 
 template <typename T>
 bool ConvertFloatArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
-  return FormatConversionCharIsFloat(conv.conv()) &&
+  return FormatConversionCharIsFloat(conv.conversion_char()) &&
          ConvertFloatImpl(v, conv, sink);
 }
 
 inline bool ConvertStringArg(string_view v, const ConversionSpec conv,
                              FormatSinkImpl *sink) {
-  if (conv.conv() != ConversionChar::s) return false;
-  if (conv.flags().basic) {
+  if (conv.conversion_char() != ConversionChar::s) return false;
+  if (conv.is_basic()) {
     sink->Append(v);
     return true;
   }
   return sink->PutPaddedString(v, conv.width(), conv.precision(),
-                               conv.flags().left);
+                               conv.has_left_flag());
 }
 
 }  // namespace
@@ -272,7 +274,7 @@ ConvertResult<Conv::s> FormatConvertImpl(string_view v,
 ConvertResult<Conv::s | Conv::p> FormatConvertImpl(const char *v,
                                                    const ConversionSpec conv,
                                                    FormatSinkImpl *sink) {
-  if (conv.conv() == ConversionChar::p)
+  if (conv.conversion_char() == ConversionChar::p)
     return {FormatConvertImpl(VoidPtr(v), conv, sink).value};
   size_t len;
   if (v == nullptr) {
@@ -289,7 +291,7 @@ ConvertResult<Conv::s | Conv::p> FormatConvertImpl(const char *v,
 // ==================== Raw pointers ====================
 ConvertResult<Conv::p> FormatConvertImpl(VoidPtr v, const ConversionSpec conv,
                                          FormatSinkImpl *sink) {
-  if (conv.conv() != ConversionChar::p) return {false};
+  if (conv.conversion_char() != ConversionChar::p) return {false};
   if (!v.value) {
     sink->Append("(nil)");
     return {true};
diff --git a/absl/strings/internal/str_format/arg.h b/absl/strings/internal/str_format/arg.h
index 7a93756305e4..1c36e3098c49 100644
--- a/absl/strings/internal/str_format/arg.h
+++ b/absl/strings/internal/str_format/arg.h
@@ -70,9 +70,11 @@ template <class AbslCord,
 ConvertResult<Conv::s> FormatConvertImpl(const AbslCord& value,
                                          ConversionSpec conv,
                                          FormatSinkImpl* sink) {
-  if (conv.conv() != ConversionChar::s) return {false};
+  if (conv.conversion_char() != ConversionChar::s) {
+    return {false};
+  }
 
-  bool is_left = conv.flags().left;
+  bool is_left = conv.has_left_flag();
   size_t space_remaining = 0;
 
   int width = conv.width();
@@ -106,8 +108,8 @@ ConvertResult<Conv::s> FormatConvertImpl(const AbslCord& value,
 }
 
 using IntegralConvertResult =
-    ConvertResult<Conv::c | Conv::numeric | Conv::star>;
-using FloatingConvertResult = ConvertResult<Conv::floating>;
+    ConvertResult<Conv::c | Conv::kNumeric | Conv::kStar>;
+using FloatingConvertResult = ConvertResult<Conv::kFloating>;
 
 // Floats.
 FloatingConvertResult FormatConvertImpl(float v, ConversionSpec conv,
@@ -185,7 +187,9 @@ struct FormatCountCaptureHelper {
                                               FormatSinkImpl* sink) {
     const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
 
-    if (conv.conv() != str_format_internal::ConversionChar::n) return {false};
+    if (conv.conversion_char() != str_format_internal::ConversionChar::n) {
+      return {false};
+    }
     *v2.p_ = static_cast<int>(sink->size());
     return {true};
   }
@@ -377,7 +381,7 @@ class FormatArgImpl {
   template <typename T>
   static bool Dispatch(Data arg, ConversionSpec spec, void* out) {
     // A `none` conv indicates that we want the `int` conversion.
-    if (ABSL_PREDICT_FALSE(spec.conv() == ConversionChar::none)) {
+    if (ABSL_PREDICT_FALSE(spec.conversion_char() == ConversionChar::kNone)) {
       return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
                       std::is_enum<T>());
     }
diff --git a/absl/strings/internal/str_format/bind.cc b/absl/strings/internal/str_format/bind.cc
index 27522fdb4f62..6980ed1d8f0e 100644
--- a/absl/strings/internal/str_format/bind.cc
+++ b/absl/strings/internal/str_format/bind.cc
@@ -147,7 +147,7 @@ class SummarizingConverter {
        << FormatConversionSpecImplFriend::FlagsToString(bound);
     if (bound.width() >= 0) ss << bound.width();
     if (bound.precision() >= 0) ss << "." << bound.precision();
-    ss << bound.conv() << "}";
+    ss << bound.conversion_char() << "}";
     Append(ss.str());
     return true;
   }
diff --git a/absl/strings/internal/str_format/checker_test.cc b/absl/strings/internal/str_format/checker_test.cc
index ea2a7681a62a..49a24b4026c3 100644
--- a/absl/strings/internal/str_format/checker_test.cc
+++ b/absl/strings/internal/str_format/checker_test.cc
@@ -9,13 +9,17 @@ ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 namespace {
 
-std::string ConvToString(Conv conv) {
+std::string ConvToString(FormatConversionCharSet conv) {
   std::string out;
 #define CONV_SET_CASE(c) \
-  if (Contains(conv, Conv::c)) out += #c;
+  if (Contains(conv, FormatConversionCharSet::c)) { \
+    out += #c; \
+  }
   ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(CONV_SET_CASE, )
 #undef CONV_SET_CASE
-  if (Contains(conv, Conv::star)) out += "*";
+  if (Contains(conv, FormatConversionCharSet::kStar)) {
+    out += "*";
+  }
   return out;
 }
 
diff --git a/absl/strings/internal/str_format/float_conversion.cc b/absl/strings/internal/str_format/float_conversion.cc
index d4c647c3ed99..d5a1ee40bc67 100644
--- a/absl/strings/internal/str_format/float_conversion.cc
+++ b/absl/strings/internal/str_format/float_conversion.cc
@@ -33,7 +33,7 @@ bool FallbackToSnprintf(const Float v, const ConversionSpec &conv,
     if (std::is_same<long double, Float>()) {
       *fp++ = 'L';
     }
-    *fp++ = FormatConversionCharToChar(conv.conv());
+    *fp++ = FormatConversionCharToChar(conv.conversion_char());
     *fp = 0;
     assert(fp < fmt + sizeof(fmt));
   }
@@ -100,17 +100,19 @@ bool ConvertNonNumericFloats(char sign_char, Float v,
   char text[4], *ptr = text;
   if (sign_char) *ptr++ = sign_char;
   if (std::isnan(v)) {
-    ptr = std::copy_n(FormatConversionCharIsUpper(conv.conv()) ? "NAN" : "nan",
-                      3, ptr);
+    ptr = std::copy_n(
+        FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3,
+        ptr);
   } else if (std::isinf(v)) {
-    ptr = std::copy_n(FormatConversionCharIsUpper(conv.conv()) ? "INF" : "inf",
-                      3, ptr);
+    ptr = std::copy_n(
+        FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3,
+        ptr);
   } else {
     return false;
   }
 
   return sink->PutPaddedString(string_view(text, ptr - text), conv.width(), -1,
-                               conv.flags().left);
+                               conv.has_left_flag());
 }
 
 // Round up the last digit of the value.
@@ -358,9 +360,9 @@ void WriteBufferToSink(char sign_char, string_view str,
                                        static_cast<int>(sign_char != 0),
                                    0)
                         : 0;
-  if (conv.flags().left) {
+  if (conv.has_left_flag()) {
     right_spaces = missing_chars;
-  } else if (conv.flags().zero) {
+  } else if (conv.has_zero_flag()) {
     zeros = missing_chars;
   } else {
     left_spaces = missing_chars;
@@ -382,9 +384,9 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
   if (std::signbit(abs_v)) {
     sign_char = '-';
     abs_v = -abs_v;
-  } else if (conv.flags().show_pos) {
+  } else if (conv.has_show_pos_flag()) {
     sign_char = '+';
-  } else if (conv.flags().sign_col) {
+  } else if (conv.has_sign_col_flag()) {
     sign_char = ' ';
   }
 
@@ -401,14 +403,14 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
 
   Buffer buffer;
 
-  switch (conv.conv()) {
+  switch (conv.conversion_char()) {
     case ConversionChar::f:
     case ConversionChar::F:
       if (!FloatToBuffer<FormatStyle::Fixed>(decomposed, precision, &buffer,
                                              nullptr)) {
         return FallbackToSnprintf(v, conv, sink);
       }
-      if (!conv.flags().alt && buffer.back() == '.') buffer.pop_back();
+      if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back();
       break;
 
     case ConversionChar::e:
@@ -417,9 +419,10 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
                                                  &exp)) {
         return FallbackToSnprintf(v, conv, sink);
       }
-      if (!conv.flags().alt && buffer.back() == '.') buffer.pop_back();
-      PrintExponent(exp, FormatConversionCharIsUpper(conv.conv()) ? 'E' : 'e',
-                    &buffer);
+      if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back();
+      PrintExponent(
+          exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
+          &buffer);
       break;
 
     case ConversionChar::g:
@@ -446,13 +449,15 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
         }
         exp = 0;
       }
-      if (!conv.flags().alt) {
+      if (!conv.has_alt_flag()) {
         while (buffer.back() == '0') buffer.pop_back();
         if (buffer.back() == '.') buffer.pop_back();
       }
       if (exp) {
-        PrintExponent(exp, FormatConversionCharIsUpper(conv.conv()) ? 'E' : 'e',
-                      &buffer);
+        PrintExponent(
+            exp,
+            FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
+            &buffer);
       }
       break;
 
diff --git a/absl/strings/internal/str_format/parser_test.cc b/absl/strings/internal/str_format/parser_test.cc
index 1b1ee030f183..51eb53f5a4cf 100644
--- a/absl/strings/internal/str_format/parser_test.cc
+++ b/absl/strings/internal/str_format/parser_test.cc
@@ -52,7 +52,7 @@ TEST(ConversionCharTest, Names) {
     X(f), X(F), X(e), X(E), X(g), X(G), X(a), X(A),  // float
     X(n), X(p),                                      // misc
 #undef X
-    {ConversionChar::none, '\0'},
+    {ConversionChar::kNone, '\0'},
   };
   // clang-format on
   for (auto e : kExpect) {
diff --git a/absl/strings/numbers_test.cc b/absl/strings/numbers_test.cc
index bd4e11621992..7db85e754da7 100644
--- a/absl/strings/numbers_test.cc
+++ b/absl/strings/numbers_test.cc
@@ -40,6 +40,7 @@
 #include "absl/random/distributions.h"
 #include "absl/random/random.h"
 #include "absl/strings/internal/numbers_test_common.h"
+#include "absl/strings/internal/ostringstream.h"
 #include "absl/strings/internal/pow10_helper.h"
 #include "absl/strings/str_cat.h"
 
diff --git a/absl/strings/str_format_test.cc b/absl/strings/str_format_test.cc
index 554dca720735..f0d1f0ad28a7 100644
--- a/absl/strings/str_format_test.cc
+++ b/absl/strings/str_format_test.cc
@@ -540,19 +540,19 @@ TEST_F(ParsedFormatTest, UncheckedCorrect) {
   EXPECT_EQ("[ABC]{d:1$d}[DEF]", SummarizeParsedFormat(*f));
 
   std::string format = "%sFFF%dZZZ%f";
-  auto f2 =
-      ExtendedParsedFormat<Conv::string, Conv::d, Conv::floating>::New(format);
+  auto f2 = ExtendedParsedFormat<Conv::kString, Conv::d, Conv::kFloating>::New(
+      format);
 
   ASSERT_TRUE(f2);
   EXPECT_EQ("{s:1$s}[FFF]{d:2$d}[ZZZ]{f:3$f}", SummarizeParsedFormat(*f2));
 
-  f2 = ExtendedParsedFormat<Conv::string, Conv::d, Conv::floating>::New(
+  f2 = ExtendedParsedFormat<Conv::kString, Conv::d, Conv::kFloating>::New(
       "%s %d %f");
 
   ASSERT_TRUE(f2);
   EXPECT_EQ("{s:1$s}[ ]{d:2$d}[ ]{f:3$f}", SummarizeParsedFormat(*f2));
 
-  auto star = ExtendedParsedFormat<Conv::star, Conv::d>::New("%*d");
+  auto star = ExtendedParsedFormat<Conv::kStar, Conv::d>::New("%*d");
   ASSERT_TRUE(star);
   EXPECT_EQ("{*d:2$1$*d}", SummarizeParsedFormat(*star));