Address review comments

Author: frederick-vs-ja

libcxx/docs/ReleaseNotes/22.rst

@@ -61,7 +61,7 @@ ABI Affecting Changes
 - The ``const_iterator`` member type of ``std::deque`` is now corrected to hold a (possibly fancy) pointer to the
   (possibly fancy) pointer allocated in the internal map. E.g. when the allocators use fancy pointers, the internal map
   stores ``fancy_ptr<T>`` objects, and the previous strategy accessed these objects via ``const fancy_ptr<const T>``
-  lvalues, which usually caused core language undefined behavior. Now ``const_iterator`` stores
+  lvalues, caused undefined behavior. Now ``const_iterator`` stores
   ``fancy_ptr<const fancy_ptr<T>>`` instead of ``fancy_ptr<const fancy_ptr<const T>>``, and ABI break can happen when
   such two types have incompatible layouts. This is necessary for reducing undefined behavior and ``constexpr`` support
   for ``deque`` in C++26, so we do not provide any way to opt-out of that behavior.

libcxx/include/deque

@@ -535,7 +535,7 @@ public:
   using const_reference = const value_type&;
 
   using iterator       = __deque_iterator<value_type, pointer, reference, __map_pointer, difference_type>;
-  using const_iterator = // Use of __map_const_pointer is merely kept for API stability.
+  using const_iterator = // Use of __map_const_pointer is merely kept for stability of const_iterator's true name.
       __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer, difference_type>;
   using reverse_iterator       = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;

libcxx/test/libcxx/containers/sequences/deque/abi.compile.pass.cpp

@@ -8,11 +8,8 @@
 
 // UNSUPPORTED: libcpp-abi-no-compressed-pair-padding
 
-#include <cstddef>
 #include <cstdint>
 #include <deque>
-#include <iterator>
-#include <type_traits>
 
 #include "min_allocator.h"
 #include "test_allocator.h"
@@ -23,107 +20,7 @@ class small_pointer {
   std::uint16_t offset;
 
 public:
-  using value_type        = typename std::remove_cv<T>::type;
-  using difference_type   = std::int16_t;
-  using reference         = T&;
-  using pointer           = T*;
-  using iterator_category = std::random_access_iterator_tag;
-
-  small_pointer() : offset() {}
-  small_pointer(std::nullptr_t) : offset() {}
-
-  template <class CT,
-            typename std::enable_if<std::is_same<const T, CT>::value && !std::is_const<T>::value, int>::type = 0>
-  operator small_pointer<CT>() const;
-  template <
-      class Void,
-      typename std::enable_if<std::is_same<Void, void>::value && std::is_convertible<T*, void*>::value, int>::type = 0>
-  operator small_pointer<Void>() const;
-  template <
-      class CVoid,
-      typename std::enable_if<std::is_same<CVoid, const void>::value && std::is_convertible<T*, const void*>::value,
-                              int>::type = 0>
-  operator small_pointer<CVoid>() const;
-
-  explicit operator bool() const;
-
   T& operator*() const;
-  T* operator->() const;
-  T& operator[](difference_type) const;
-
-  small_pointer& operator++();
-  small_pointer operator++(int);
-  small_pointer& operator--();
-  small_pointer operator--(int);
-  small_pointer& operator+=(difference_type);
-  small_pointer& operator-=(difference_type);
-
-  friend small_pointer operator+(small_pointer, difference_type) { return small_pointer(); }
-  friend small_pointer operator+(difference_type, small_pointer) { return small_pointer(); }
-  friend small_pointer operator-(small_pointer, difference_type) { return small_pointer(); }
-  friend difference_type operator-(small_pointer, small_pointer) { return 0; }
-
-  friend bool operator==(small_pointer, small_pointer) { return true; }
-#if TEST_STD_VER < 20
-  friend bool operator!=(small_pointer, small_pointer) { return false; }
-#endif
-  friend bool operator<(small_pointer, small_pointer) { return false; }
-  friend bool operator<=(small_pointer, small_pointer) { return true; }
-  friend bool operator>(small_pointer, small_pointer) { return false; }
-  friend bool operator>=(small_pointer, small_pointer) { return true; }
-
-  friend bool operator==(small_pointer, std::nullptr_t) { return true; }
-#if TEST_STD_VER < 20
-  friend bool operator==(std::nullptr_t, small_pointer) { return true; }
-  friend bool operator!=(small_pointer, std::nullptr_t) { return false; }
-  friend bool operator!=(std::nullptr_t, small_pointer) { return false; }
-#endif
-
-  small_pointer pointer_to(T&);
-};
-
-template <>
-class small_pointer<const void> {
-  std::uint16_t offset;
-
-public:
-  small_pointer() : offset() {}
-  small_pointer(std::nullptr_t) : offset() {}
-
-  template <class CT, typename std::enable_if<std::is_convertible<CT*, const void*>::value, int>::type = 0>
-  explicit operator small_pointer<CT>() const;
-
-  explicit operator bool() const;
-
-  friend bool operator==(small_pointer, std::nullptr_t) { return true; }
-#if TEST_STD_VER < 20
-  friend bool operator==(std::nullptr_t, small_pointer) { return true; }
-  friend bool operator!=(small_pointer, std::nullptr_t) { return false; }
-  friend bool operator!=(std::nullptr_t, small_pointer) { return false; }
-#endif
-};
-
-template <>
-class small_pointer<void*> {
-  std::uint16_t offset;
-
-public:
-  small_pointer() : offset() {}
-  small_pointer(std::nullptr_t) : offset() {}
-
-  operator small_pointer<const void>() const;
-
-  template <class T, typename std::enable_if<std::is_convertible<T*, void*>::value, int>::type = 0>
-  explicit operator small_pointer<T>() const;
-
-  explicit operator bool() const;
-
-  friend bool operator==(small_pointer, std::nullptr_t) { return true; }
-#if TEST_STD_VER < 20
-  friend bool operator==(std::nullptr_t, small_pointer) { return true; }
-  friend bool operator!=(small_pointer, std::nullptr_t) { return false; }
-  friend bool operator!=(std::nullptr_t, small_pointer) { return false; }
-#endif
 };
 
 template <class T>
@@ -139,8 +36,8 @@ class small_iter_allocator {
   template <class U>
   small_iter_allocator(small_iter_allocator<U>) TEST_NOEXCEPT {}
 
-  pointer allocate(std::size_t n);
-  void deallocate(pointer p, std::size_t);
+  T* allocate(std::size_t n);
+  void deallocate(T* p, std::size_t);
 
   friend bool operator==(small_iter_allocator, small_iter_allocator) { return true; }
   friend bool operator!=(small_iter_allocator, small_iter_allocator) { return false; }
@@ -159,8 +56,8 @@ class final_small_iter_allocator final {
   template <class U>
   final_small_iter_allocator(final_small_iter_allocator<U>) TEST_NOEXCEPT {}
 
-  pointer allocate(std::size_t n);
-  void deallocate(pointer p, std::size_t);
+  T* allocate(std::size_t n);
+  void deallocate(T* p, std::size_t);
 
   friend bool operator==(final_small_iter_allocator, final_small_iter_allocator) { return true; }
   friend bool operator!=(final_small_iter_allocator, final_small_iter_allocator) { return false; }