Address ldionne's comments

Author: winner245

libcxx/include/__cxx03/string

@@ -2483,9 +2483,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__
     __throw_length_error();
   pointer __old_p = __get_pointer();
   size_type __cap =
-      __old_cap < __ms / 2 - __alignment
-          ? __recommend(std::max<size_type>(__old_cap + __delta_cap, 2 * __old_cap))
-          : __ms - 1;
+      __old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1;
   __annotate_delete();
   auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
   pointer __p       = __allocation.ptr;
@@ -2528,9 +2526,7 @@ _LIBCPP_DEPRECATED_("use __grow_by_without_replace") basic_string<_CharT, _Trait
     __throw_length_error();
   pointer __old_p = __get_pointer();
   size_type __cap =
-      __old_cap < __ms / 2 - __alignment
-          ? __recommend(std::max<size_type>(__old_cap + __delta_cap, 2 * __old_cap))
-          : __ms - 1;
+      __old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1;
   __annotate_delete();
   auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
   pointer __p       = __allocation.ptr;

libcxx/include/__cxx03/vector

@@ -2328,7 +2328,7 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const {
   const size_type __cap = capacity();
   if (__cap >= __ms / 2)
     return __ms;
-  return std::max<size_type>(2 * __cap, __align_it(__new_size));
+  return std::max(2 * __cap, __align_it(__new_size));
 }
 
 //  Default constructs __n objects starting at __end_

libcxx/include/string

@@ -2629,7 +2629,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__
     __throw_length_error();
   pointer __old_p = __get_pointer();
   size_type __cap =
-      __old_cap < __ms / 2 - __alignment ? __recommend(std::max<size_type>(__old_cap + __delta_cap, 2 * __old_cap)) : __ms;
+      __old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms;
   __annotate_delete();
   auto __guard      = std::__make_scope_guard(__annotate_new_size(*this));
   auto __allocation = std::__allocate_at_least(__alloc_, __cap + 1);

libcxx/test/std/containers/sequences/vector.bool/sized_allocator.pass.cpp

@@ -9,7 +9,9 @@
 // <vector>
 // vector<bool>
 
-// This test examines ambiguous calls to std::max in vector<bool>
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
+
+// This test ensures that ambiguous calls to std::max in vector<bool> is fixed.
 // Fix https://github.com/llvm/llvm-project/issues/121713
 
 #include <cassert>
@@ -20,93 +22,74 @@
 #include <new>
 #include <vector>
 
+#include "sized_allocator.h"
 #include "test_macros.h"
 
-template <typename T, typename SIZE_TYPE = std::size_t, typename DIFF_TYPE = std::ptrdiff_t>
-class sized_allocator {
-  template <typename U, typename Sz, typename Diff>
-  friend class sized_allocator;
-
-public:
-  using value_type                  = T;
-  using size_type                   = SIZE_TYPE;
-  using difference_type             = DIFF_TYPE;
-  using propagate_on_container_swap = std::true_type;
-
-  TEST_CONSTEXPR_CXX20 explicit sized_allocator(int d = 0) : data_(d) {}
-
-  template <typename U, typename Sz, typename Diff>
-  TEST_CONSTEXPR_CXX20 sized_allocator(const sized_allocator<U, Sz, Diff>& a) TEST_NOEXCEPT : data_(a.data_) {}
-
-  TEST_CONSTEXPR_CXX20 T* allocate(size_type n) {
-    if (n > max_size())
-      TEST_THROW(std::bad_array_new_length());
-    return std::allocator<T>().allocate(n);
-  }
-
-  TEST_CONSTEXPR_CXX20 void deallocate(T* p, size_type n) TEST_NOEXCEPT { std::allocator<T>().deallocate(p, n); }
-
-  TEST_CONSTEXPR size_type max_size() const TEST_NOEXCEPT {
-    return std::numeric_limits<size_type>::max() / sizeof(value_type);
-  }
-
-private:
-  int data_;
-
-  TEST_CONSTEXPR friend bool operator==(const sized_allocator& a, const sized_allocator& b) {
-    return a.data_ == b.data_;
-  }
-  TEST_CONSTEXPR friend bool operator!=(const sized_allocator& a, const sized_allocator& b) {
-    return a.data_ != b.data_;
-  }
-};
-
 TEST_CONSTEXPR_CXX20 bool tests() {
   // The following tests are typical ways to trigger reallocations where `std::max` is used to calculate the capacity.
+  // The purpose of these tests is to ensure that the ambiguous internal calls to `std::max` have been fixed.
   {
     using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.resize(10);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
   {
     using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.assign(10, true);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
   {
     using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.insert(c.end(), true);
+    assert(c.size() == 1);
+    assert(c.capacity() >= 1);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.insert(c.end(), 10, true);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.push_back(true);
+    assert(c.size() == 1);
+    assert(c.capacity() >= 1);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.resize(10, true);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
   {
     using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.resize(10);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
   {
     using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.resize(10);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
   {
     using Alloc = sized_allocator<bool, std::size_t, std::ptrdiff_t>;
     std::vector<bool, Alloc> c(Alloc(1));
     c.resize(10);
+    assert(c.size() == 10);
+    assert(c.capacity() >= 10);
   }
 
   return true;