[libc++] Use [[no_unique_address]] directly proof-of-concept

[philnik]

Summary

This is a proof-of-concept for using [[no_unique_address]] directly in the places where __compressed_pair is used currently. For now this won't work because there is no way to get the functionality of [[no_unique_address]] in C++03.

[philnik]

• Try to fix CI

[philnik]

• Next try

[philnik]

More compiler support/removed C++03 support is required to make this work properly.

libcxx/include/__memory/compressed_pair.h

 
 template <class _T1, class _T2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
     _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) {
   __x.swap(__y);
 }
 
+template <class _Type, class _EnableIfFinal = void>
+struct __compressed_pair_padding {};
+
+template <class _Type>
+struct __compressed_pair_padding<_Type, __enable_if_t<__libcpp_is_final<_Type>::value && is_empty<_Type>::value> > {
+  char __padding_;
+};
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_COMPRESSED_PAIR_H

libcxx/include/string

#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
 
     struct __raw
     {
         size_type __words[__n_words];
     };
 
-    struct __rep
-    {
-        union
-        {
-            __long  __l;
-            __short __s;
-            __raw   __r;
-        };
-    };
-
-    __compressed_pair<__rep, allocator_type> __r_;
+    _LIBCPP_NO_UNIQUE_ADDRESS __compressed_pair_padding<allocator_type> __padding;
+    _LIBCPP_NO_UNIQUE_ADDRESS allocator_type __alloc;
 
 public:
     _LIBCPP_TEMPLATE_DATA_VIS
     static const size_type npos = -1;
 
     _LIBCPP_INLINE_VISIBILITY basic_string()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
 

 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     basic_string(basic_string&& __str, const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
-      _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
-      __init(__s, traits_type::length(__s));
+    basic_string(const _CharT* __str) {
+      _LIBCPP_ASSERT(__str != nullptr, "basic_string(const char*) detected nullptr");
+      __init(__str, traits_type::length(__str));
       _VSTD::__debug_db_insert_c(this);
     }
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
         _LIBCPP_INLINE_VISIBILITY
-        basic_string(const _CharT* __s, const _Allocator& __a);
+        basic_string(const _CharT* __str, const _Allocator& __a);
 
 #if _LIBCPP_STD_VER > 20
     basic_string(nullptr_t) = delete;
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(const _CharT* __s, size_type __n);
+    basic_string(const _CharT* __str, size_type __n);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
+    basic_string(const _CharT* __str, size_type __n, const _Allocator& __a);
     _LIBCPP_INLINE_VISIBILITY
     basic_string(size_type __n, _CharT __c);
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
         _LIBCPP_INLINE_VISIBILITY
         basic_string(size_type __n, _CharT __c, const _Allocator& __a);
 
     basic_string(const basic_string& __str, size_type __pos, size_type __n,

 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
      _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
+    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __str) {return assign(__str);}
 #if _LIBCPP_STD_VER > 20
     basic_string& operator=(nullptr_t) = delete;
 #endif
     basic_string& operator=(value_type __c);
 
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT
#endif
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
             && !__is_same_uncvref<_Tp, basic_string >::value,
             basic_string&
         >
                                             operator+=(const _Tp& __t)            {__self_view __sv = __t; return append(__sv);}
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s)     {return append(__s);}
+    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __str)     {return append(__str);}
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c)            {push_back(__c); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     basic_string& append(const basic_string& __str);
 
#endif // _LIBCPP_CXX03_LANG
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
             && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   append(const _Tp& __t, size_type __pos, size_type __n=npos);
-    basic_string& append(const value_type* __s, size_type __n);
-    basic_string& append(const value_type* __s);
+    basic_string& append(const value_type* __str, size_type __n);
+    basic_string& append(const value_type* __str);
     basic_string& append(size_type __n, value_type __c);
 
     _LIBCPP_INLINE_VISIBILITY
     void __append_default_init(size_type __n);
 
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __is_exactly_cpp17_input_iterator<_InputIterator>::value,
             basic_string&
         >
     _LIBCPP_INLINE_VISIBILITY
     append(_InputIterator __first, _InputIterator __last) {
-      const basic_string __temp(__first, __last, __alloc());
+      const basic_string __temp(__first, __last, __alloc);
       append(__temp.data(), __temp.size());
       return *this;
     }
     template<class _ForwardIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
#endif
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
             && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   assign(const _Tp & __t, size_type __pos, size_type __n=npos);
-    basic_string& assign(const value_type* __s, size_type __n);
-    basic_string& assign(const value_type* __s);
+    basic_string& assign(const value_type* __str, size_type __n);
+    basic_string& assign(const value_type* __str);
     basic_string& assign(size_type __n, value_type __c);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __is_exactly_cpp17_input_iterator<_InputIterator>::value,
             basic_string&
         >
#endif // _LIBCPP_CXX03_LANG
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
     basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
-    basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
-    basic_string& insert(size_type __pos, const value_type* __s);
+    basic_string& insert(size_type __pos, const value_type* __str, size_type __n);
+    basic_string& insert(size_type __pos, const value_type* __str);
     basic_string& insert(size_type __pos, size_type __n, value_type __c);
     iterator      insert(const_iterator __pos, value_type __c);
     _LIBCPP_INLINE_VISIBILITY
     iterator      insert(const_iterator __pos, size_type __n, value_type __c);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
#endif // _LIBCPP_CXX03_LANG
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
         >
                   replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
-    basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
-    basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
+    basic_string& replace(size_type __pos, size_type __n1, const value_type* __str, size_type __n2);
+    basic_string& replace(size_type __pos, size_type __n1, const value_type* __str);
     basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
     _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
         >
                   replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
 
     _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
+    basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __str, size_type __n);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
+    basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __str);
     _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __is_cpp17_input_iterator<_InputIterator>::value,
             basic_string&
         >
         replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
         {return replace(__i1, __i2, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
-    size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
+    size_type copy(value_type* __str, size_type __n, size_type __pos = 0) const;
     _LIBCPP_INLINE_VISIBILITY
     basic_string substr(size_type __pos = 0, size_type __n = npos) const;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_string& __str)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value);
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     const value_type* c_str() const _NOEXCEPT {return data();}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT  {return _VSTD::__to_address(__get_pointer());}
 #if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
     _LIBCPP_INLINE_VISIBILITY
     value_type* data()             _NOEXCEPT  {return _VSTD::__to_address(__get_pointer());}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
+    allocator_type get_allocator() const _NOEXCEPT {return __alloc;}
 
     _LIBCPP_INLINE_VISIBILITY
     size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
-    size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+    size_type find(const value_type* __str, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+    size_type find(const value_type* __str, size_type __pos = 0) const _NOEXCEPT;
     size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
-    size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+    size_type rfind(const value_type* __str, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+    size_type rfind(const value_type* __str, size_type __pos = npos) const _NOEXCEPT;
     size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
-    size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+    size_type find_first_of(const value_type* __str, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+    size_type find_first_of(const value_type* __str, size_type __pos = 0) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
-    size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+    size_type find_last_of(const value_type* __str, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+    size_type find_last_of(const value_type* __str, size_type __pos = npos) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT;
-    size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+    size_type find_first_not_of(const value_type* __str, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+    size_type find_first_not_of(const value_type* __str, size_type __pos = 0) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
     __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
         >
               find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
-    size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+    size_type find_last_not_of(const value_type* __str, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+    size_type find_last_not_of(const value_type* __str, size_type __pos = npos) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     int compare(const basic_string& __str) const _NOEXCEPT;
 
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
#endif
     template <class _Tp>
     inline _LIBCPP_INLINE_VISIBILITY
         __enable_if_t
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string>::value,
             int
         >
         compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
-    int compare(const value_type* __s) const _NOEXCEPT;
-    int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
-    int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
+    int compare(const value_type* __str) const _NOEXCEPT;
+    int compare(size_type __pos1, size_type __n1, const value_type* __str) const;
+    int compare(size_type __pos1, size_type __n1, const value_type* __str, size_type __n2) const;
 
 #if _LIBCPP_STD_VER > 17
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool starts_with(__self_view __sv) const noexcept
     { return __self_view(data(), size()).starts_with(__sv); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool starts_with(value_type __c) const noexcept
     { return !empty() && _Traits::eq(front(), __c); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
-    bool starts_with(const value_type* __s) const noexcept
-    { return starts_with(__self_view(__s)); }
+    bool starts_with(const value_type* __str) const noexcept
+    { return starts_with(__self_view(__str)); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool ends_with(__self_view __sv) const noexcept
     { return __self_view(data(), size()).ends_with( __sv); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool ends_with(value_type __c) const noexcept
     { return !empty() && _Traits::eq(back(), __c); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
-    bool ends_with(const value_type* __s) const noexcept
-    { return ends_with(__self_view(__s)); }
+    bool ends_with(const value_type* __str) const noexcept
+    { return ends_with(__self_view(__str)); }
 #endif
 
 #if _LIBCPP_STD_VER > 20
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool contains(__self_view __sv) const noexcept
     { return __self_view(data(), size()).contains(__sv); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
     bool contains(value_type __c) const noexcept
     { return __self_view(data(), size()).contains(__c); }
 
     constexpr _LIBCPP_INLINE_VISIBILITY
-    bool contains(const value_type* __s) const
-    { return __self_view(data(), size()).contains(__s); }
+    bool contains(const value_type* __str) const
+    { return __self_view(data(), size()).contains(__str); }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity);
 
     _LIBCPP_INLINE_VISIBILITY
     bool __is_long() const _NOEXCEPT
-        {return bool(__r_.first().__s.__size_ & __short_mask);}
+        {return bool(__s.__size_ & __short_mask);}
 
 #if _LIBCPP_DEBUG_LEVEL == 2
 
     bool __dereferenceable(const const_iterator* __i) const;
     bool __decrementable(const const_iterator* __i) const;
     bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
     bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
 
iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
         for (__p += __ip; __first != __last; ++__p, ++__first)
             traits_type::assign(*__p, *__first);
 
         return begin() + __ip;
     }
 
-    _LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
-    _LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
-
 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
-    void __set_short_size(size_type __s) _NOEXCEPT
+    void __set_short_size(size_type __str) _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
+        {__s.__size_ = (unsigned char)(__str << 1);}
 #   else
-        {__r_.first().__s.__size_ = (unsigned char)(__s);}
+        {__s.__size_ = (unsigned char)(__str);}
 #   endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_short_size() const _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {return __r_.first().__s.__size_ >> 1;}
+        {__s.__size_ >> 1;}
 #   else
-        {return __r_.first().__s.__size_;}
+        {__s.__size_;}
 #   endif
 
 #else  // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
-    void __set_short_size(size_type __s) _NOEXCEPT
+    void __set_short_size(size_type __sz) _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {__r_.first().__s.__size_ = (unsigned char)(__s);}
+        {__s.__size_ = (unsigned char)(__sz);}
 #   else
-        {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
+        {__s.__size_ = (unsigned char)(__sz << 1);}
 #   endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_short_size() const _NOEXCEPT
 #   ifdef _LIBCPP_BIG_ENDIAN
-        {return __r_.first().__s.__size_;}
+        {return __s.__size_;}
 #   else
-        {return __r_.first().__s.__size_ >> 1;}
+        {return __s.__size_ >> 1;}
 #   endif
 
 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
     _LIBCPP_INLINE_VISIBILITY
-    void __set_long_size(size_type __s) _NOEXCEPT
-        {__r_.first().__l.__size_ = __s;}
+    void __set_long_size(size_type __sz) _NOEXCEPT
+        {__l.__size_ = __sz;}
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_long_size() const _NOEXCEPT
-        {return __r_.first().__l.__size_;}
+        {return __l.__size_;}
     _LIBCPP_INLINE_VISIBILITY
-    void __set_size(size_type __s) _NOEXCEPT
-        {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
+    void __set_size(size_type __sz) _NOEXCEPT
+        {if (__is_long()) __set_long_size(__sz); else __set_short_size(__sz);}
 
     _LIBCPP_INLINE_VISIBILITY
-    void __set_long_cap(size_type __s) _NOEXCEPT
-        {__r_.first().__l.__cap_  = __long_mask | __s;}
+    void __set_long_cap(size_type __sz) _NOEXCEPT
+        {__l.__cap_  = __long_mask | __sz;}
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_long_cap() const _NOEXCEPT
-        {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
+        {return __l.__cap_ & size_type(~__long_mask);}
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_long_pointer(pointer __p) _NOEXCEPT
-        {__r_.first().__l.__data_ = __p;}
+        {__l.__data_ = __p;}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_long_pointer() _NOEXCEPT
-        {return __r_.first().__l.__data_;}
+        {return __l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_long_pointer() const _NOEXCEPT
-        {return __r_.first().__l.__data_;}
+        {return __l.__data_;}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_short_pointer() _NOEXCEPT
-        {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
+        {return pointer_traits<pointer>::pointer_to(__s.__data_[0]);}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_short_pointer() const _NOEXCEPT
-        {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
+        {return pointer_traits<const_pointer>::pointer_to(__s.__data_[0]);}
     _LIBCPP_INLINE_VISIBILITY
     pointer __get_pointer() _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
     _LIBCPP_INLINE_VISIBILITY
     const_pointer __get_pointer() const _NOEXCEPT
         {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
 
     _LIBCPP_INLINE_VISIBILITY
     void __zero() _NOEXCEPT
         {
-            size_type (&__a)[__n_words] = __r_.first().__r.__words;
+            size_type (&__a)[__n_words] = __r.__words;
             for (unsigned __i = 0; __i < __n_words; ++__i)
                 __a[__i] = 0;
         }
 
     template <size_type __a> static
         _LIBCPP_INLINE_VISIBILITY
-        size_type __align_it(size_type __s) _NOEXCEPT
-            {return (__s + (__a-1)) & ~(__a-1);}
+        size_type __align_it(size_type __str) _NOEXCEPT
+            {return (__str + (__a-1)) & ~(__a-1);}
     enum {__alignment = 16};
     static _LIBCPP_INLINE_VISIBILITY
-    size_type __recommend(size_type __s) _NOEXCEPT
+    size_type __recommend(size_type __str) _NOEXCEPT
         {
-        if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1;
+        if (__str < __min_cap) return static_cast<size_type>(__min_cap) - 1;
         size_type __guess = __align_it<sizeof(value_type) < __alignment ?
-                     __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
+                     __alignment/sizeof(value_type) : 1 > (__str+1) - 1;
         if (__guess == __min_cap) ++__guess;
         return __guess;
         }
 
     inline
-    void __init(const value_type* __s, size_type __sz, size_type __reserve);
+    void __init(const value_type* __str, size_type __sz, size_type __reserve);
     inline
-    void __init(const value_type* __s, size_type __sz);
+    void __init(const value_type* __str, size_type __sz);
     inline
     void __init(size_type __n, value_type __c);
 
     // Slow path for the (inlined) copy constructor for 'long' strings.
     // Always externally instantiated and not inlined.
-    // Requires that __s is zero terminated.
+    // Requires that __str is zero terminated.
     // The main reason for this function to exist is because for unstable, we
     // want to allow inlining of the copy constructor. However, we don't want
     // to call the __init() functions as those are marked as inline which may
     // result in over-aggressive inlining by the compiler, where our aim is
     // to only inline the fast path code directly in the ctor.
-    void __init_copy_ctor_external(const value_type* __s, size_type __sz);
+    void __init_copy_ctor_external(const value_type* __str, size_type __sz);
 
     template <class _InputIterator>
     inline
     __enable_if_t
     <
         __is_exactly_cpp17_input_iterator<_InputIterator>::value
     >
     __init(_InputIterator __first, _InputIterator __last);
#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
     void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                                size_type __n_copy,  size_type __n_del,
                                size_type __n_add, const value_type* __p_new_stuff);
 
     // __assign_no_alias is invoked for assignment operations where we
     // have proof that the input does not alias the current instance.
     // For example, operator=(basic_string) performs a 'self' check.
     template <bool __is_short>
-    basic_string& __assign_no_alias(const value_type* __s, size_type __n);
+    basic_string& __assign_no_alias(const value_type* __str, size_type __n);
 
     _LIBCPP_INLINE_VISIBILITY
     void __erase_to_end(size_type __pos);
 
     // __erase_external_with_move is invoked for erase() invocations where
     // `n ~= npos`, likely requiring memory moves on the string data.
     void __erase_external_with_move(size_type __pos, size_type __n);
 
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const basic_string& __str)
         {__copy_assign_alloc(__str, integral_constant<bool,
                       __alloc_traits::propagate_on_container_copy_assignment::value>());}
 
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const basic_string& __str, true_type)
         {
-            if (__alloc() == __str.__alloc())
-                __alloc() = __str.__alloc();
+            if (__alloc == __str.__alloc)
+                __alloc = __str.__alloc;
             else
             {
                 if (!__str.__is_long())
                 {
                     __clear_and_shrink();
-                    __alloc() = __str.__alloc();
+                    __alloc = __str.__alloc;
                 }
                 else
                 {
-                    allocator_type __a = __str.__alloc();
+                    allocator_type __a = __str.__alloc;
                     pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap());
                     __clear_and_shrink();
-                    __alloc() = _VSTD::move(__a);
+                    __alloc = _VSTD::move(__a);
                     __set_long_pointer(__p);
                     __set_long_cap(__str.__get_long_cap());
                     __set_long_size(__str.size());
                 }
             }
         }
 
     _LIBCPP_INLINE_VISIBILITY
__move_assign_alloc(basic_string& __str)
             is_nothrow_move_assignable<allocator_type>::value)
     {__move_assign_alloc(__str, integral_constant<bool,
                       __alloc_traits::propagate_on_container_move_assignment::value>());}
 
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(basic_string& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
-            __alloc() = _VSTD::move(__c.__alloc());
+            __alloc = _VSTD::move(__c.__alloc);
         }
 
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(basic_string&, false_type)
         _NOEXCEPT
         {}
 
-    basic_string& __assign_external(const value_type* __s);
-    basic_string& __assign_external(const value_type* __s, size_type __n);
+    basic_string& __assign_external(const value_type* __str);
+    basic_string& __assign_external(const value_type* __str, size_type __n);
 
-    // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
-    inline basic_string& __assign_short(const value_type* __s, size_type __n) {
+    // Assigns the value in __str, guaranteed to be __n < __min_cap in length.
+    inline basic_string& __assign_short(const value_type* __str, size_type __n) {
       pointer __p = __is_long()
                         ? (__set_long_size(__n), __get_long_pointer())
                         : (__set_short_size(__n), __get_short_pointer());
-      traits_type::move(_VSTD::__to_address(__p), __s, __n);
+      traits_type::move(_VSTD::__to_address(__p), __str, __n);
       traits_type::assign(__p[__n], value_type());
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
       __set_size(__newsz);
       __invalidate_iterators_past(__newsz);
       traits_type::assign(__p[__newsz], value_type());
#else
     (void)__pos;
 #endif // _LIBCPP_DEBUG_LEVEL == 2
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-     : __r_(__default_init_tag(), __default_init_tag())
 {
     _VSTD::__debug_db_insert_c(this);
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-: __r_(__default_init_tag(), __a)
+: __alloc(__a)
 {
     _VSTD::__debug_db_insert_c(this);
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
+void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __str,
                                                        size_type __sz,
                                                        size_type __reserve)
 {
     if (__reserve > max_size())
         __throw_length_error();
     pointer __p;
     if (__fits_in_sso(__reserve))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__reserve);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc_traits::allocate(__alloc, __cap+1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
     }
-    traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
+    traits_type::copy(_VSTD::__to_address(__p), __str, __sz);
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
-basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
+basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __str, size_type __sz)
 {
     if (__sz > max_size())
         __throw_length_error();
     pointer __p;
     if (__fits_in_sso(__sz))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__sz);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc_traits::allocate(__alloc, __cap+1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
     }
-    traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
+    traits_type::copy(_VSTD::__to_address(__p), __str, __sz);
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class>
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __str, const _Allocator& __a)
+    : __alloc(__a)
 {
-    _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
-    __init(__s, traits_type::length(__s));
+    _LIBCPP_ASSERT(__str != nullptr, "basic_string(const char*, allocator) detected nullptr");
+    __init(__str, traits_type::length(__str));
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
-     : __r_(__default_init_tag(), __default_init_tag())
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __str, size_type __n)
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
-    __init(__s, __n);
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "basic_string(const char*, n) detected nullptr");
+    __init(__str, __n);
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __str, size_type __n, const _Allocator& __a)
+    : __alloc(__a)
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
-    __init(__s, __n);
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
+    __init(__str, __n);
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
-    : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
+    : __alloc(__alloc_traits::select_on_container_copy_construction(__str.__alloc))
 {
     if (!__str.__is_long())
-        __r_.first().__r = __str.__r_.first().__r;
+        __r = __str.__r;
     else
         __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
                                   __str.__get_long_size());
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     const basic_string& __str, const allocator_type& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     if (!__str.__is_long())
-        __r_.first().__r = __str.__r_.first().__r;
+        __r = __str.__r;
     else
         __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
                                   __str.__get_long_size());
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
-    const value_type* __s, size_type __sz) {
+    const value_type* __str, size_type __sz) {
   pointer __p;
   if (__fits_in_sso(__sz)) {
     __p = __get_short_pointer();
     __set_short_size(__sz);
   } else {
     if (__sz > max_size())
       __throw_length_error();
     size_t __cap = __recommend(__sz);
-    __p = __alloc_traits::allocate(__alloc(), __cap + 1);
+    __p = __alloc_traits::allocate(__alloc, __cap + 1);
     __set_long_pointer(__p);
     __set_long_cap(__cap + 1);
     __set_long_size(__sz);
   }
-  traits_type::copy(_VSTD::__to_address(__p), __s, __sz + 1);
+  traits_type::copy(_VSTD::__to_address(__p), __str, __sz + 1);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-    : __r_(_VSTD::move(__str.__r_))
+    : __r(__str.__r), __alloc(std::move(__str.__alloc))
 {
     __str.__zero();
     _VSTD::__debug_db_insert_c(this);
 #if _LIBCPP_DEBUG_LEVEL == 2
     if (!__libcpp_is_constant_evaluated() && __is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
-    if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
+    if (__str.__is_long() && __a != __str.__alloc) // copy, not move
         __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
     else
     {
-        __r_.first().__r = __str.__r_.first().__r;
+        __r = __str.__r;
         __str.__zero();
     }
     _VSTD::__debug_db_insert_c(this);
 #if _LIBCPP_DEBUG_LEVEL == 2
     if (!__libcpp_is_constant_evaluated() && __is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
     if (__fits_in_sso(__n))
     {
         __set_short_size(__n);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__n);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc_traits::allocate(__alloc, __cap+1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__n);
     }
     traits_type::assign(_VSTD::__to_address(__p), __n, __c);
     traits_type::assign(__p[__n], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
-     : __r_(__default_init_tag(), __default_init_tag())
 {
     __init(__n, __c);
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     __init(__n, __c);
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
                                                         size_type __pos, size_type __n,
                                                         const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         __throw_out_of_range();
     __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
                                                         const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         __throw_out_of_range();
     __init(__str.data() + __pos, __str_sz - __pos);
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
              const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     __self_view __sv0 = __t;
     __self_view __sv = __sv0.substr(__pos, __n);
     __init(__sv.data(), __sv.size());
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
-     : __r_(__default_init_tag(), __default_init_tag())
 {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, class>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator>

 #endif // _LIBCPP_NO_EXCEPTIONS
     for (; __first != __last; ++__first)
         push_back(*__first);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         if (__is_long())
-            __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+            __alloc_traits::deallocate(__alloc, __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator>
 __enable_if_t
basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
     if (__fits_in_sso(__sz))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__sz);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc_traits::allocate(__alloc, __cap+1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
     }
 
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
     for (; __first != __last; ++__first, (void) ++__p)
         traits_type::assign(*__p, *__first);
     traits_type::assign(*__p, value_type());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         if (__is_long())
-            __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+            __alloc_traits::deallocate(__alloc, __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
-     : __r_(__default_init_tag(), __default_init_tag())
 {
     __init(__first, __last);
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, class>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
                                                         const allocator_type& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     __init(__first, __last);
     _VSTD::__debug_db_insert_c(this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
-basic_string<_CharT, _Traits, _Allocator>::basic_string(
-    initializer_list<_CharT> __il)
-     : __r_(__default_init_tag(), __default_init_tag())
+basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<_CharT> __il)
 {
     __init(__il.begin(), __il.end());
     _VSTD::__debug_db_insert_c(this);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
     initializer_list<_CharT> __il, const _Allocator& __a)
-    : __r_(__default_init_tag(), __a)
+    : __alloc(__a)
 {
     __init(__il.begin(), __il.end());
     _VSTD::__debug_db_insert_c(this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     if (!__libcpp_is_constant_evaluated())
         __get_db()->__erase_c(this);
 #endif
     if (__is_long())
-        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+        __alloc_traits::deallocate(__alloc, __get_long_pointer(), __get_long_cap());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
     (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
      size_type __n_copy,  size_type __n_del,     size_type __n_add, const value_type* __p_new_stuff)
 {
     size_type __ms = max_size();
     if (__delta_cap > __ms - __old_cap - 1)
         __throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
                           __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
-    pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
+    pointer __p = __alloc_traits::allocate(__alloc, __cap+1);
     __invalidate_all_iterators();
     if (__n_copy != 0)
         traits_type::copy(_VSTD::__to_address(__p),
                           _VSTD::__to_address(__old_p), __n_copy);
     if (__n_add != 0)
         traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
                           _VSTD::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
     if (__old_cap+1 != __min_cap)
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
+        __alloc_traits::deallocate(__alloc, __old_p, __old_cap+1);
     __set_long_pointer(__p);
     __set_long_cap(__cap+1);
     __old_sz = __n_copy + __n_add + __sec_cp_sz;
     __set_long_size(__old_sz);
     traits_type::assign(__p[__old_sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 void
 basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                                                      size_type __n_copy,  size_type __n_del,     size_type __n_add)
 {
     size_type __ms = max_size();
     if (__delta_cap > __ms - __old_cap)
         __throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
                           __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
-    pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
+    pointer __p = __alloc_traits::allocate(__alloc, __cap+1);
     __invalidate_all_iterators();
     if (__n_copy != 0)
         traits_type::copy(_VSTD::__to_address(__p),
                           _VSTD::__to_address(__old_p), __n_copy);
     size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
     if (__sec_cp_sz != 0)
         traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
                           _VSTD::__to_address(__old_p) + __n_copy + __n_del,
                           __sec_cp_sz);
     if (__old_cap+1 != __min_cap)
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
+        __alloc_traits::deallocate(__alloc, __old_p, __old_cap+1);
     __set_long_pointer(__p);
     __set_long_cap(__cap+1);
 }
 
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 template <bool __is_short>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
-    const value_type* __s, size_type __n) {
+    const value_type* __str, size_type __n) {
   size_type __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();
   if (__n < __cap) {
     pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
     __is_short ? __set_short_size(__n) : __set_long_size(__n);
-    traits_type::copy(_VSTD::__to_address(__p), __s, __n);
+    traits_type::copy(_VSTD::__to_address(__p), __str, __n);
     traits_type::assign(__p[__n], value_type());
     __invalidate_iterators_past(__n);
   } else {
     size_type __sz = __is_short ? __get_short_size() : __get_long_size();
-    __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
+    __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __str);
   }
   return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_external(
-    const value_type* __s, size_type __n) {
+    const value_type* __str, size_type __n) {
   size_type __cap = capacity();
   if (__cap >= __n) {
     value_type* __p = _VSTD::__to_address(__get_pointer());
-    traits_type::move(__p, __s, __n);
+    traits_type::move(__p, __str, __n);
     return __null_terminate_at(__p, __n);
   } else {
     size_type __sz = size();
-    __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
+    __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __str);
     return *this;
   }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __str, size_type __n)
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::assign received nullptr");
     return (__builtin_constant_p(__n) && __fits_in_sso(__n))
-               ? __assign_short(__s, __n)
-               : __assign_external(__s, __n);
+               ? __assign_short(__str, __n)
+               : __assign_external(__str, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
 {
     size_type __cap = capacity();
     if (__cap < __n)

 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
   if (this != &__str) {
     __copy_assign_alloc(__str);
     if (!__is_long()) {
       if (!__str.__is_long()) {
-        __r_.first().__r = __str.__r_.first().__r;
+        __r = __str.__r;
       } else {
         return __assign_no_alias<true>(__str.data(), __str.size());
       }
     } else {
       return __assign_no_alias<false>(__str.data(), __str.size());
     }
   }
   return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
     _NOEXCEPT_(__alloc_traits::is_always_equal::value)
 {
-    if (__alloc() != __str.__alloc())
+    if (__alloc != __str.__alloc)
         assign(__str);
     else
         __move_assign(__str, true_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
 #if _LIBCPP_STD_VER > 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 #endif
 {
   if (__is_long()) {
-    __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
+    __alloc_traits::deallocate(__alloc, __get_long_pointer(),
                                __get_long_cap());
 #if _LIBCPP_STD_VER <= 14
     if (!is_nothrow_move_assignable<allocator_type>::value) {
       __set_short_size(0);
       traits_type::assign(__get_short_pointer()[0], value_type());
     }
 #endif
   }
   __move_assign_alloc(__str);
-  __r_.first() = __str.__r_.first();
+  __r = __str.__r;
   __str.__set_short_size(0);
   traits_type::assign(__str.__get_short_pointer()[0], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)

 template<class _InputIterator>
 __enable_if_t
 <
      __is_exactly_cpp17_input_iterator<_InputIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
 >
 basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
-    const basic_string __temp(__first, __last, __alloc());
+    const basic_string __temp(__first, __last, __alloc);
     assign(__temp.data(), __temp.size());
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
 __enable_if_t
 <
if (__string_is_trivial_iterator<_ForwardIterator>::value &&
         for (; __first != __last; ++__p, (void) ++__first)
             traits_type::assign(*__p, *__first);
         traits_type::assign(*__p, value_type());
         __set_size(__n);
         __invalidate_iterators_past(__n);
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
+        const basic_string __temp(__first, __last, __alloc);
         assign(__temp.data(), __temp.size());
     }
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
     if (__pos > __sz)
         __throw_out_of_range();
     return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
 }
 
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) {
-  return __assign_external(__s, traits_type::length(__s));
+basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __str) {
+  return __assign_external(__str, traits_type::length(__str));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __str)
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
-    return __builtin_constant_p(*__s)
-               ? (__fits_in_sso(traits_type::length(__s))
-                      ? __assign_short(__s, traits_type::length(__s))
-                      : __assign_external(__s, traits_type::length(__s)))
-               : __assign_external(__s);
+    _LIBCPP_ASSERT(__str != nullptr, "string::assign received nullptr");
+    return __builtin_constant_p(*__str)
+               ? (__fits_in_sso(traits_type::length(__str))
+                      ? __assign_short(__str, traits_type::length(__str))
+                      : __assign_external(__str, traits_type::length(__str)))
+               : __assign_external(__str);
 }
 // append
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __str, size_type __n)
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::append received nullptr");
     size_type __cap = capacity();
     size_type __sz = size();
     if (__cap - __sz >= __n)
     {
         if (__n)
         {
             value_type* __p = _VSTD::__to_address(__get_pointer());
-            traits_type::copy(__p + __sz, __s, __n);
+            traits_type::copy(__p + __sz, __str, __n);
             __sz += __n;
             __set_size(__sz);
             traits_type::assign(__p[__sz], value_type());
         }
     }
     else
-        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
+        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __str);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
 {
     if (__n)
if (__n)
             pointer __p = __get_pointer() + __sz;
             for (; __first != __last; ++__p, (void) ++__first)
                 traits_type::assign(*__p, *__first);
             traits_type::assign(*__p, value_type());
             __set_size(__sz + __n);
         }
         else
         {
-            const basic_string __temp(__first, __last, __alloc());
+            const basic_string __temp(__first, __last, __alloc);
             append(__temp.data(), __temp.size());
         }
     }
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
     size_type __sz = __sv.size();
     if (__pos > __sz)
         __throw_out_of_range();
     return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __str)
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
-    return append(__s, traits_type::length(__s));
+    _LIBCPP_ASSERT(__str != nullptr, "string::append received nullptr");
+    return append(__str, traits_type::length(__str));
 }
 
 // insert
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __str, size_type __n)
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::insert received nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         __throw_out_of_range();
     size_type __cap = capacity();
     if (__cap - __sz >= __n)
     {
         if (__n)
         {
             value_type* __p = _VSTD::__to_address(__get_pointer());
             size_type __n_move = __sz - __pos;
             if (__n_move != 0)
             {
-                if (__p + __pos <= __s && __s < __p + __sz)
-                    __s += __n;
+                if (__p + __pos <= __str && __str < __p + __sz)
+                    __str += __n;
                 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
             }
-            traits_type::move(__p + __pos, __s, __n);
+            traits_type::move(__p + __pos, __str, __n);
             __sz += __n;
             __set_size(__sz);
             traits_type::assign(__p[__sz], value_type());
         }
     }
     else
-        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
+        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __str);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
 {
     size_type __sz = size();
<
    __is_exactly_cpp17_input_iterator<_InputIterator>::value,
    typename basic_string<_CharT, _Traits, _Allocator>::iterator
 >
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
 {
   _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
                        "string::insert(iterator, range) called with an iterator not"
                        " referring to this string");
-  const basic_string __temp(__first, __last, __alloc());
+  const basic_string __temp(__first, __last, __alloc);
   return insert(__pos, __temp.data(), __temp.data() + __temp.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
 __enable_if_t
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
if (__n == 0)
         return begin() + __ip;
 
     if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first))
     {
         return __insert_from_safe_copy(__n, __ip, __first, __last);
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
+        const basic_string __temp(__first, __last, __alloc);
         return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
     }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
     size_type __str_sz = __sv.size();
     if (__pos2 > __str_sz)
         __throw_out_of_range();
     return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __str)
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
-    return insert(__pos, __s, traits_type::length(__s));
+    _LIBCPP_ASSERT(__str != nullptr, "string::insert received nullptr");
+    return insert(__pos, __str, traits_type::length(__str));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
 {
     _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
                          "string::insert(iterator, character) called with an iterator not"
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
   insert(static_cast<size_type>(__p), __n, __c);
   return begin() + __p;
 }
 
 // replace
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
+basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __str, size_type __n2)
     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 {
-    _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
+    _LIBCPP_ASSERT(__n2 == 0 || __str != nullptr, "string::replace received nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         __throw_out_of_range();
     __n1 = _VSTD::min(__n1, __sz - __pos);
     size_type __cap = capacity();
     if (__cap - __sz + __n1 >= __n2)
     {
         value_type* __p = _VSTD::__to_address(__get_pointer());
         if (__n1 != __n2)
         {
             size_type __n_move = __sz - __pos - __n1;
             if (__n_move != 0)
             {
                 if (__n1 > __n2)
                 {
-                    traits_type::move(__p + __pos, __s, __n2);
+                    traits_type::move(__p + __pos, __str, __n2);
                     traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
                     return __null_terminate_at(__p, __sz + (__n2 - __n1));
                 }
-                if (__p + __pos < __s && __s < __p + __sz)
+                if (__p + __pos < __str && __str < __p + __sz)
                 {
-                    if (__p + __pos + __n1 <= __s)
-                        __s += __n2 - __n1;
-                    else // __p + __pos < __s < __p + __pos + __n1
+                    if (__p + __pos + __n1 <= __str)
+                        __str += __n2 - __n1;
+                    else // __p + __pos < __str < __p + __pos + __n1
                     {
-                        traits_type::move(__p + __pos, __s, __n1);
+                        traits_type::move(__p + __pos, __str, __n1);
                         __pos += __n1;
-                        __s += __n2;
+                        __str += __n2;
                         __n2 -= __n1;
                         __n1 = 0;
                     }
                 }
                 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
             }
         }
-        traits_type::move(__p + __pos, __s, __n2);
+        traits_type::move(__p + __pos, __str, __n2);
         return __null_terminate_at(__p, __sz + (__n2 - __n1));
     }
     else
-        __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
+        __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __str);
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
 {
     size_type __sz = size();

 __enable_if_t
 <
     __is_cpp17_input_iterator<_InputIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
 >
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
                                                    _InputIterator __j1, _InputIterator __j2)
 {
-    const basic_string __temp(__j1, __j2, __alloc());
+    const basic_string __temp(__j1, __j2, __alloc);
     return replace(__i1, __i2, __temp);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
 {
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
     size_type __str_sz = __sv.size();
     if (__pos2 > __str_sz)
         __throw_out_of_range();
     return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __str)
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
-    return replace(__pos, __n1, __s, traits_type::length(__s));
+    _LIBCPP_ASSERT(__str != nullptr, "string::replace received nullptr");
+    return replace(__pos, __n1, __str, traits_type::length(__str));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
 {
     return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
                    __str.data(), __str.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __str, size_type __n)
 {
-    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
+    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __str, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __str)
 {
-    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
+    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __str);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
 {
     return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
if (__n > __sz) {
         __erase_to_end(__n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
 {
-    size_type __m = __alloc_traits::max_size(__alloc());
+    size_type __m = __alloc_traits::max_size(__alloc);
 #ifdef _LIBCPP_BIG_ENDIAN
     return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
 #else
     return __m - __alignment;
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
if (__target_capacity == __min_cap - 1)
         __was_long = true;
         __now_long = false;
         __new_data = __get_short_pointer();
         __p = __get_long_pointer();
     }
     else
     {
         if (__target_capacity > __cap)
-            __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
+            __new_data = __alloc_traits::allocate(__alloc, __target_capacity+1);
         else
         {
         #ifndef _LIBCPP_NO_EXCEPTIONS
             try
             {
         #endif // _LIBCPP_NO_EXCEPTIONS
-                __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
+                __new_data = __alloc_traits::allocate(__alloc, __target_capacity+1);
         #ifndef _LIBCPP_NO_EXCEPTIONS
             }
             catch (...)
             {
                 return;
             }
         #else  // _LIBCPP_NO_EXCEPTIONS
             if (__new_data == nullptr)
                 return;
         #endif // _LIBCPP_NO_EXCEPTIONS
         }
         __now_long = true;
         __was_long = __is_long();
         __p = __get_pointer();
     }
     traits_type::copy(_VSTD::__to_address(__new_data),
                         _VSTD::__to_address(__p), size()+1);
     if (__was_long)
-        __alloc_traits::deallocate(__alloc(), __p, __cap+1);
+        __alloc_traits::deallocate(__alloc, __p, __cap+1);
     if (__now_long)
     {
         __set_long_cap(__target_capacity+1);
         __set_long_size(__sz);
         __set_long_pointer(__new_data);
     }
     else
         __set_short_size(__sz);

 basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT
 {
     _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
     return *(data() + size() - 1);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
+basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __str, size_type __n, size_type __pos) const
 {
     size_type __sz = size();
     if (__pos > __sz)
         __throw_out_of_range();
     size_type __rlen = _VSTD::min(__n, __sz - __pos);
-    traits_type::copy(__s, data() + __pos, __rlen);
+    traits_type::copy(__str, data() + __pos, __rlen);
     return __rlen;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
 {
-    return basic_string(*this, __pos, __n, __alloc());
+    return basic_string(*this, __pos, __n, __alloc);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 void
 basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT
if (!__libcpp_is_constant_evaluated()) {
         if (!__str.__is_long())
             __get_db()->__invalidate_all(&__str);
         __get_db()->swap(this, &__str);
     }
 #endif
     _LIBCPP_ASSERT(
         __alloc_traits::propagate_on_container_swap::value ||
         __alloc_traits::is_always_equal::value ||
-        __alloc() == __str.__alloc(), "swapping non-equal allocators");
-    _VSTD::swap(__r_.first(), __str.__r_.first());
-    _VSTD::__swap_allocator(__alloc(), __str.__alloc());
+        __alloc == __str.__alloc, "swapping non-equal allocators");
+    _VSTD::swap(__r, __str.__r);
+    _VSTD::__swap_allocator(__alloc, __str.__alloc);
 }
 
 // find
 
 template <class _Traits>
 struct _LIBCPP_HIDDEN __traits_eq
 {
     typedef typename _Traits::char_type char_type;
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
         {return _Traits::eq(__x, __y);}
 };
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __str,
                                                 size_type __pos,
                                                 size_type __n) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::find(): received nullptr");
     return __str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+        (data(), size(), __str, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
                                                 size_type __pos) const _NOEXCEPT
 {
basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
     __self_view __sv = __t;
     return __str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __str,
                                                 size_type __pos) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
+    _LIBCPP_ASSERT(__str != nullptr, "string::find(): received nullptr");
     return __str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+        (data(), size(), __str, __pos, traits_type::length(__str));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
                                                 size_type __pos) const _NOEXCEPT
 {
     return __str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // rfind
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __str,
                                                  size_type __pos,
                                                  size_type __n) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::rfind(): received nullptr");
     return __str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+        (data(), size(), __str, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
                                                  size_type __pos) const _NOEXCEPT
 {
basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
     __self_view __sv = __t;
     return __str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __str,
                                                  size_type __pos) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
+    _LIBCPP_ASSERT(__str != nullptr, "string::rfind(): received nullptr");
     return __str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+        (data(), size(), __str, __pos, traits_type::length(__str));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
                                                  size_type __pos) const _NOEXCEPT
 {
     return __str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // find_first_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __str,
                                                          size_type __pos,
                                                          size_type __n) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::find_first_of(): received nullptr");
     return __str_find_first_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+        (data(), size(), __str, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
                                                          size_type __pos) const _NOEXCEPT
 {
basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
     __self_view __sv = __t;
     return __str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __str,
                                                          size_type __pos) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
+    _LIBCPP_ASSERT(__str != nullptr, "string::find_first_of(): received nullptr");
     return __str_find_first_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+        (data(), size(), __str, __pos, traits_type::length(__str));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
                                                          size_type __pos) const _NOEXCEPT
 {
     return find(__c, __pos);
 }
 
 // find_last_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __str,
                                                         size_type __pos,
                                                         size_type __n) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::find_last_of(): received nullptr");
     return __str_find_last_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+        (data(), size(), __str, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
                                                         size_type __pos) const _NOEXCEPT
 {
basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
     __self_view __sv = __t;
     return __str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __str,
                                                         size_type __pos) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
+    _LIBCPP_ASSERT(__str != nullptr, "string::find_last_of(): received nullptr");
     return __str_find_last_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+        (data(), size(), __str, __pos, traits_type::length(__str));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
                                                         size_type __pos) const _NOEXCEPT
 {
     return rfind(__c, __pos);
 }
 
 // find_first_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __str,
                                                              size_type __pos,
                                                              size_type __n) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::find_first_not_of(): received nullptr");
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+        (data(), size(), __str, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
                                                              size_type __pos) const _NOEXCEPT
 {
basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
     __self_view __sv = __t;
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __str,
                                                              size_type __pos) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
+    _LIBCPP_ASSERT(__str != nullptr, "string::find_first_not_of(): received nullptr");
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+        (data(), size(), __str, __pos, traits_type::length(__str));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
                                                              size_type __pos) const _NOEXCEPT
 {
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // find_last_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __str,
                                                             size_type __pos,
                                                             size_type __n) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
+    _LIBCPP_ASSERT(__n == 0 || __str != nullptr, "string::find_last_not_of(): received nullptr");
     return __str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+        (data(), size(), __str, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
                                                             size_type __pos) const _NOEXCEPT
 {
basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
     __self_view __sv = __t;
     return __str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __str,
                                                             size_type __pos) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
+    _LIBCPP_ASSERT(__str != nullptr, "string::find_last_not_of(): received nullptr");
     return __str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+        (data(), size(), __str, __pos, traits_type::length(__str));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
                                                             size_type __pos) const _NOEXCEPT
 {

 {
     return compare(__self_view(__str));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
-                                                   const value_type* __s,
+                                                   const value_type* __str,
                                                    size_type __n2) const
 {
-    _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
+    _LIBCPP_ASSERT(__n2 == 0 || __str != nullptr, "string::compare(): received nullptr");
     size_type __sz = size();
     if (__pos1 > __sz || __n2 == npos)
         __throw_out_of_range();
     size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
-    int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
+    int __r = traits_type::compare(data() + __pos1, __str, _VSTD::min(__rlen, __n2));
     if (__r == 0)
     {
         if (__rlen < __n2)
             __r = -1;
         else if (__rlen > __n2)
             __r = 1;
     }
     return __r;
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __pos2,
                                                    size_type __n2) const
 {
     return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 int
-basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
+basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __str) const _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
-    return compare(0, npos, __s, traits_type::length(__s));
+    _LIBCPP_ASSERT(__str != nullptr, "string::compare(): received nullptr");
+    return compare(0, npos, __str, traits_type::length(__str));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
-                                                   const value_type* __s) const
+                                                   const value_type* __str) const
 {
-    _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
-    return compare(__pos1, __n1, __s, traits_type::length(__s));
+    _LIBCPP_ASSERT(__str != nullptr, "string::compare(): received nullptr");
+    return compare(__pos1, __n1, __str, traits_type::length(__str));
 }
 
 // __invariants
 
 template<class _CharT, class _Traits, class _Allocator>
 inline
 bool
 basic_string<_CharT, _Traits, _Allocator>::__invariants() const

 template<class _CharT, class _Traits, class _Allocator>
 inline
 void
 basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
 {
     clear();
     if(__is_long())
     {
-        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
+        __alloc_traits::deallocate(__alloc, __get_long_pointer(), capacity() + 1);
         __set_long_cap(0);
         __set_short_size(0);
         traits_type::assign(*__get_short_pointer(), value_type());
     }
 }
 
 // operator==
 

libcxx/test/libcxx/no_unique_address_keep_abi.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL: c++03
+
+#include <memory>
+#include <string>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+struct Empty1 {};
+struct Empty2 {};
+
+struct FinalEmpty1 final {};
+struct FinalEmpty2 final {};
+
+struct NotEmpty1 { char c[22]; };
+struct NotEmpty2 { char c[10]; };
+
+struct FinalNotEmpty1 final { char c[22]; };
+struct FinalNotEmpty2 final { char c[10]; };
+
+struct FitsInPadding { int i; char c; };
+
+template <class T, class U>
+struct new_compressed_pair {
+  _LIBCPP_NO_UNIQUE_ADDRESS std::__compressed_pair_padding<T> __padding1;
+  _LIBCPP_NO_UNIQUE_ADDRESS T __element1;
+  _LIBCPP_NO_UNIQUE_ADDRESS std::__compressed_pair_padding<U> __padding2;
+  _LIBCPP_NO_UNIQUE_ADDRESS U __element2;
+};
+
+template <class _Tp, int _Idx, bool _CanBeEmptyBase = std::is_empty<_Tp>::value && !std::__libcpp_is_final<_Tp>::value>
+struct compressed_pair_elem { _Tp __value_; };
+
+template <class _Tp, int _Idx>
+struct compressed_pair_elem<_Tp, _Idx, true> : private _Tp {};
+
+template <class _T1, class _T2>
+class compressed_pair : private compressed_pair_elem<_T1, 0>,
+                        private compressed_pair_elem<_T2, 1> {};
+
+static_assert(sizeof(new_compressed_pair<int, long>) ==                      sizeof(compressed_pair<int, long>), "");
+static_assert(sizeof(new_compressed_pair<Empty1, Empty2>) ==                 sizeof(compressed_pair<Empty1, Empty2>), "");
+static_assert(sizeof(new_compressed_pair<FinalEmpty1, Empty2>) ==            sizeof(compressed_pair<FinalEmpty1, Empty2>), "");
+static_assert(sizeof(new_compressed_pair<Empty1, FinalEmpty2>) ==            sizeof(compressed_pair<Empty1, FinalEmpty2>), "");
+static_assert(sizeof(new_compressed_pair<FinalEmpty1, FinalEmpty2>) ==       sizeof(compressed_pair<FinalEmpty1, FinalEmpty2>), "");
+static_assert(sizeof(new_compressed_pair<NotEmpty1, FinalEmpty2>) ==         sizeof(compressed_pair<NotEmpty1, FinalEmpty2>), "");
+static_assert(sizeof(new_compressed_pair<NotEmpty1, NotEmpty2>) ==           sizeof(compressed_pair<NotEmpty1, NotEmpty2>), "");
+static_assert(sizeof(new_compressed_pair<FinalNotEmpty1, FinalNotEmpty2>) == sizeof(compressed_pair<FinalNotEmpty1, FinalNotEmpty2>), "");
+static_assert(sizeof(new_compressed_pair<FitsInPadding, char>) ==            sizeof(compressed_pair<FitsInPadding, char>), "");
+
+static_assert(sizeof(std::string) == 2 * sizeof(size_t) + sizeof(compressed_pair<void*, std::allocator<int>>), "");
+#ifndef TEST_HAS_NO_CHAR8_T
+static_assert(sizeof(std::u8string) ==  2 * sizeof(size_t) + sizeof(compressed_pair<void*, std::allocator<int>>), "");
+#endif
+static_assert(sizeof(std::u16string) ==  2 * sizeof(size_t) + sizeof(compressed_pair<void*, std::allocator<int>>), "");
+static_assert(sizeof(std::u32string) ==  2 * sizeof(size_t) + sizeof(compressed_pair<void*, std::allocator<int>>), "");
+
+namespace N1 {
+template <class CharT>
+using alloc_string = std::basic_string<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+static_assert(sizeof(alloc_string<char>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+#ifndef TEST_HAS_NO_CHAR8_T
+static_assert(sizeof(alloc_string<char8_t>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+#endif
+static_assert(sizeof(alloc_string<char16_t>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+static_assert(sizeof(alloc_string<char32_t>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+} // namespace N1
+
+namespace N2 {
+template <class CharT>
+using alloc_string = std::basic_string<CharT, std::char_traits<CharT>, non_default_test_allocator<CharT>>;
+
+static_assert(sizeof(alloc_string<char>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+#ifndef TEST_HAS_NO_CHAR8_T
+static_assert(sizeof(alloc_string<char8_t>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+#endif
+static_assert(sizeof(alloc_string<char16_t>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+static_assert(sizeof(alloc_string<char32_t>) == 2 * sizeof(unsigned) + sizeof(compressed_pair<void*, test_allocator<char>>), "");
+} // namespace N2