[libc++][NFCI] Remove unnecessary exception-throwing base classes

[ldionne]

Summary

split_buffer_common was entirely unused, and deque_base_common
was unused except for two calls to __throw_out_of_range(), which have
been inlined.

The usual intent of the __xxx_base_common base classes is to localize
where the exception-throwing code is instantiated, however that wasn't
the case here because we never explicitly instantiated those base classes
in the shared library, unlike what we do for basic_string and vector.

[• Quuxplusone]

libcxx/include/deque

915–916

I notice these were never _LIBCPP_HIDE_FROM_ABI or whatever. But that's fine, right? I believe I agree that this PR doesn't cause an ABI break in any interesting sense.

[• Quuxplusone]

libcxx/include/deque

1853

I spoke slightly too soon. You are gratuitously changing the what-message here, right? That's definitely not "NFCI", and I'm ambivalent as to whether it's a good idea. The old message is just the word "deque", which is not great, but it at least has the virtue of taking up not-too-many bytes of storage. Whereas adding "...index out of bounds" to an exception of type std::out_of_range really isn't adding anything useful, is it? The user should already know what "out of range" means.

I suggest doing the NFC part alone, and then following up with a non-NFC change from "deque" to "deque::at" — spending 4 bytes to get a bit more useful info, but not going further than that.

[ldionne]

libcxx/include/deque

1853

Hmm, I guess you're right - I'm fine with just keeping "deque" only.

[ldionne]

Address review comments.

libcxx/include/deque

915–916

Yes, that should be fine. Anyone using these functions had a weak-definition in their TU, which the linker deduped across TUs (based on the ODR). Now we're just removing those, so that new code compiled against the new headers won't need or generate those weak definitions. It would be a risk of ODR-violation if we changed the definition of these functions because existing code was compiled with one definition and new code would be compiled with a new definition, but that's not what we're doing here.

libcxx/include/__split_buffer

 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <bool>
-class __split_buffer_common
-{
-protected:
-    _LIBCPP_NORETURN void __throw_length_error() const;
-    _LIBCPP_NORETURN void __throw_out_of_range() const;
-};
-
 template <class _Tp, class _Allocator = allocator<_Tp> >
 struct __split_buffer
-    : private __split_buffer_common<true>
 {
 private:
     __split_buffer(const __split_buffer&);
     __split_buffer& operator=(const __split_buffer&);
 public:
     typedef _Tp                                             value_type;
     typedef _Allocator                                      allocator_type;
     typedef typename remove_reference<allocator_type>::type __alloc_rr;

libcxx/include/deque

while (__n > 0)
         }
         __r = _VSTD::move_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
     return __r;
 }
 
-template <bool>
-class __deque_base_common
-{
-protected:
-    _LIBCPP_NORETURN void __throw_length_error() const;
-    _LIBCPP_NORETURN void __throw_out_of_range() const;
-};
-
-template <bool __b>
-void
-__deque_base_common<__b>::__throw_length_error() const
-{
-    _VSTD::__throw_length_error("deque");
-}
-
-template <bool __b>
-void
-__deque_base_common<__b>::__throw_out_of_range() const
-{
-    _VSTD::__throw_out_of_range("deque");
-}
-
 template <class _Tp, class _Allocator>
 class __deque_base
-    : protected __deque_base_common<true>
 {
     __deque_base(const __deque_base& __c);
     __deque_base& operator=(const __deque_base& __c);
 public:
     typedef _Allocator                               allocator_type;
     typedef allocator_traits<allocator_type>         __alloc_traits;
     typedef typename __alloc_traits::size_type       size_type;
 

 }
 
 template <class _Tp, class _Allocator>
 inline
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::at(size_type __i)
 {
     if (__i >= __base::size())
-        __base::__throw_out_of_range();
+        _VSTD::__throw_out_of_range("deque");
     size_type __p = __base::__start_ + __i;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::at(size_type __i) const
 {
     if (__i >= __base::size())
-        __base::__throw_out_of_range();
+        _VSTD::__throw_out_of_range("deque");
     size_type __p = __base::__start_ + __i;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::front() _NOEXCEPT