[libc++][ranges] Implement the changes to container adaptors from P1206 (`ranges::to`):

[var-const]

Summary

• add the from_range_t constructors and the related deduction guides;
• add the push_range member function.

(Note: this patch is split from https://reviews.llvm.org/D142335)

[var-const]

Rebase; copy the changes to include/deque from D149827 to make the patch compile.

[var-const]

Fix CI.

[var-const]

Sync with D149827.

[var-const]

Fix the CI.

[var-const]

Rebase (which makes the changes to deque go away).

[ldionne]

This LGTM w/ a few comments! Thanks!

libcxx/test/std/containers/container.adaptors/from_range_container_adaptors.h

10

This include guard is wrong.

91

IMO these should move out of this file and be local to priority.queue/from_range.pass.cpp.

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/from_range.pass.cpp

18–23

Nitpick, but let's move those above includes. Please check in other test files too.

libcxx/test/support/unwrap_container_adaptor.h

24–30

This doesn't require C++20.

[paulkirth]

We're seeing some failures related to the following tests in our CI after this patch. Other failures are masking our CI right now so I'm not 100% sure this is still an issue, but I didn't notice any forward fixes or reverts related to this change.

Failing bot: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8779076649243827361/overview

llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/queue.sh.cpp
llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/stack.sh.cpp

********************
Failed Tests (2):
  llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/queue.sh.cpp
  llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/stack.sh.cpp


Testing Time: 318.39s
  Skipped          :    18
  Unsupported      :  2666
  Passed           : 14168
  Expectedly Failed:   102
  Failed           :     2
FAILED: CMakeFiles/check-runtimes /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/CMakeFiles/check-runtimes

[Mordante]

In D149829#4401617, @paulkirth wrote:

We're seeing some failures related to the following tests in our CI after this patch. Other failures are masking our CI right now so I'm not 100% sure this is still an issue, but I didn't notice any forward fixes or reverts related to this change.

Failing bot: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8779076649243827361/overview

llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/queue.sh.cpp
llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/stack.sh.cpp

********************
Failed Tests (2):
  llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/queue.sh.cpp
  llvm-libc++-static.cfg.in :: /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/transitive_includes.gen.py/stack.sh.cpp


Testing Time: 318.39s
  Skipped          :    18
  Unsupported      :  2666
  Passed           : 14168
  Expectedly Failed:   102
  Failed           :     2
FAILED: CMakeFiles/check-runtimes /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/CMakeFiles/check-runtimes

I committed a fix for this yesterday. Is this issue still present for you?

libcxx/include/deque

public:
     explicit deque(size_type n);
     explicit deque(size_type n, const allocator_type& a); // C++14
     deque(size_type n, const value_type& v);
     deque(size_type n, const value_type& v, const allocator_type& a);
     template <class InputIterator>
         deque(InputIterator f, InputIterator l);
     template <class InputIterator>
         deque(InputIterator f, InputIterator l, const allocator_type& a);
+    template<container-compatible-range<T> R>
+        deque(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     deque(const deque& c);
     deque(deque&& c)
         noexcept(is_nothrow_move_constructible<allocator_type>::value);
     deque(initializer_list<value_type> il, const Allocator& a = allocator_type());
     deque(const deque& c, const allocator_type& a);
     deque(deque&& c, const allocator_type& a);
     ~deque();
 
     deque& operator=(const deque& c);
     deque& operator=(deque&& c)
         noexcept(
              allocator_type::propagate_on_container_move_assignment::value &&
              is_nothrow_move_assignable<allocator_type>::value);
     deque& operator=(initializer_list<value_type> il);
 
     template <class InputIterator>
         void assign(InputIterator f, InputIterator l);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& v);
     void assign(initializer_list<value_type> il);
 
     allocator_type get_allocator() const noexcept;
 
     // iterators:
 
     iterator       begin() noexcept;
public:
     reference front();
     const_reference front() const;
     reference back();
     const_reference back() const;
 
     // modifiers:
     void push_front(const value_type& v);
     void push_front(value_type&& v);
+    template<container-compatible-range<T> R>
+      void prepend_range(R&& rg); // C++23
     void push_back(const value_type& v);
     void push_back(value_type&& v);
+    template<container-compatible-range<T> R>
+      void append_range(R&& rg); // C++23
     template <class... Args> reference emplace_front(Args&&... args);  // reference in C++17
     template <class... Args> reference emplace_back(Args&&... args);   // reference in C++17
     template <class... Args> iterator emplace(const_iterator p, Args&&... args);
     iterator insert(const_iterator p, const value_type& v);
     iterator insert(const_iterator p, value_type&& v);
     iterator insert(const_iterator p, size_type n, const value_type& v);
     template <class InputIterator>
         iterator insert(const_iterator p, InputIterator f, InputIterator l);
+    template<container-compatible-range<T> R>
+      iterator insert_range(const_iterator position, R&& rg); // C++23
     iterator insert(const_iterator p, initializer_list<value_type> il);
     void pop_front();
     void pop_back();
     iterator erase(const_iterator p);
     iterator erase(const_iterator f, const_iterator l);
     void swap(deque& c)
         noexcept(allocator_traits<allocator_type>::is_always_equal::value);  // C++17
     void clear() noexcept;
 };
 
 template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
    deque(InputIterator, InputIterator, Allocator = Allocator())
    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  deque(from_range_t, R&&, Allocator = Allocator())
+    -> deque<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class T, class Allocator>
     bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
 template <class T, class Allocator>
     bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20
 template <class T, class Allocator>
     bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20
 template <class T, class Allocator>
     bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20
template <class T, class Allocator, class Predicate>
     erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_backward.h>
+#include <__algorithm/copy_n.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__format/enable_insertable.h>
+#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/segmented_iterator.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_destructor.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/temp_value.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <stdexcept>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
#endif
     }
 
     template <class _InputIter>
     _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l,
               typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
     template <class _InputIter>
     _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
               typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI deque(from_range_t, _Range&& __range,
+      const allocator_type& __a = allocator_type())
+    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      __append_with_size(ranges::begin(__range), ranges::distance(__range));
+
+    } else {
+      for (auto&& __e : __range) {
+        emplace_back(std::forward<decltype(__e)>(__e));
+      }
+    }
+  }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI deque(const deque& __c);
     _LIBCPP_HIDE_FROM_ABI deque(const deque& __c, const __type_identity_t<allocator_type>& __a);
 
     _LIBCPP_HIDE_FROM_ABI deque& operator=(const deque& __c);
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il);
     _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il, const allocator_type& __a);
#endif // _LIBCPP_CXX03_LANG
 
     template <class _InputIter>
     _LIBCPP_HIDE_FROM_ABI void assign(_InputIter __f, _InputIter __l,
                     typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
                                       !__is_cpp17_random_access_iterator<_InputIter>::value>::type* = 0);
     template <class _RAIter>
     _LIBCPP_HIDE_FROM_ABI void assign(_RAIter __f, _RAIter __l,
                     typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void assign_range(_Range&& __range) {
+      if constexpr (ranges::random_access_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        __assign_with_size_random_access(ranges::begin(__range), __n);
+
+      } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        __assign_with_size(ranges::begin(__range), __n);
+
+      } else {
+        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
 
     _LIBCPP_HIDE_FROM_ABI
     allocator_type get_allocator() const _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT { return __size_.second(); }
   _LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT { return __size_.second(); }
 
   // iterators:

 #else
     template <class... _Args> _LIBCPP_HIDE_FROM_ABI void      emplace_front(_Args&&... __args);
     template <class... _Args> _LIBCPP_HIDE_FROM_ABI void      emplace_back (_Args&&... __args);
 #endif
     template <class... _Args> _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);
 
     _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
     _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __v);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void prepend_range(_Range&& __range) {
+      insert_range(begin(), std::forward<_Range>(__range));
+    }
+
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void append_range(_Range&& __range) {
+      insert_range(end(), std::forward<_Range>(__range));
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v);
 
     _LIBCPP_HIDE_FROM_ABI
     iterator insert(const_iterator __p, initializer_list<value_type> __il)
         {return insert(__p, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v);
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v);
     template <class _InputIter>
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,
                          typename enable_if<__is_exactly_cpp17_input_iterator<_InputIter>::value>::type* = 0);
     template <class _ForwardIterator>
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
                         typename enable_if<__is_exactly_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
     template <class _BiIter>
     _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
                          typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type* = 0);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::bidirectional_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_bidirectional(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), __n);
+
+      } else {
+        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+      }
+    }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI void pop_front();
     _LIBCPP_HIDE_FROM_ABI void pop_back();
     _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
     _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
 
     _LIBCPP_HIDE_FROM_ABI
     void swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
bool __maybe_remove_back_spare(bool __keep_one = true) {
         __alloc_traits::deallocate(__alloc(), __map_.back(),
                                    __block_size);
         __map_.pop_back();
         return true;
       }
       return false;
     }
 
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
+
+    template <class _RandomAccessIterator>
+    _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n);
+    template <class _Iterator>
+    _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_size(_Iterator __f, difference_type __n);
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
+
+    template <class _Iterator>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_with_size(const_iterator __p, _Iterator __f, size_type __n);
+
+    template <class _BiIter, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel __sent, size_type __n);
+    template <class _BiIter>
+    _LIBCPP_HIDE_FROM_ABI
+    iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n);
+
     template <class _InpIter>
     _LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l,
                  typename enable_if<__is_exactly_cpp17_input_iterator<_InpIter>::value>::type* = 0);
     template <class _ForIter>
     _LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l,
                       typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type* = 0);
+
+    template <class _InputIterator>
+    _LIBCPP_HIDE_FROM_ABI void __append_with_size(_InputIterator __from, size_type __n);
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI void __append_with_sentinel(_InputIterator __f, _Sentinel __l);
+
     _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
     _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v);
     _LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f);
     _LIBCPP_HIDE_FROM_ABI void __add_front_capacity();
     _LIBCPP_HIDE_FROM_ABI void __add_front_capacity(size_type __n);
     _LIBCPP_HIDE_FROM_ABI void __add_back_capacity();
     _LIBCPP_HIDE_FROM_ABI void __add_back_capacity(size_type __n);
     _LIBCPP_HIDE_FROM_ABI iterator __move_and_check(iterator __f, iterator __l, iterator __r,
template<class _InputIterator,
          class _Alloc,
          class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
          class = enable_if_t<__is_allocator<_Alloc>::value>
          >
 deque(_InputIterator, _InputIterator, _Alloc)
   -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>
+          >
+deque(from_range_t, _Range&&, _Alloc = _Alloc())
+  -> deque<ranges::range_value_t<_Range>, _Alloc>;
+#endif
+
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n)
     : __start_(0), __size_(0, __default_init_tag())
 {
     if (__n > 0)
         __append(__n);
 }
 

 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 void
 deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
                                typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
                                                  !__is_cpp17_random_access_iterator<_InputIter>::value>::type*)
 {
+  __assign_with_sentinel(__f, __l);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) {
     iterator __i = begin();
     iterator __e = end();
     for (; __f != __l && __i != __e; ++__f, (void) ++__i)
         *__i = *__f;
     if (__f != __l)
-        __append(__f, __l);
+        __append_with_sentinel(std::move(__f), std::move(__l));
     else
         __erase_to_end(__i);
 }
 
 template <class _Tp, class _Allocator>
 template <class _RAIter>
 void
 deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
                                typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
 {
-    if (static_cast<size_type>(__l - __f) > size())
+  __assign_with_size_random_access(__f, __l - __f);
+}
+
+template <class _Tp, class _Allocator>
+template <class _RandomAccessIterator>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n) {
+    if (static_cast<size_type>(__n) > size())
     {
-        _RAIter __m = __f + size();
-        _VSTD::copy(__f, __m, begin());
-        __append(__m, __l);
+        auto __l = __f + size();
+        std::copy(__f, __l, begin());
+        __append_with_size(__l, __n - size());
     }
     else
-        __erase_to_end(_VSTD::copy(__f, __l, begin()));
+        __erase_to_end(std::copy_n(__f, __n, begin()));
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type __n) {
+  if (static_cast<size_type>(__n) > size()) {
+    auto __added_size = __n - size();
+
+    auto __i = begin();
+    while (__n != 0) {
+      *__i++ = *__f++;
+      --__n;
+    }
+
+    __append_with_size(__f, __added_size);
+
+  } else {
+    __erase_to_end(std::copy_n(__f, __n, begin()));
+  }
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
 {
     if (__n > size())
     {

 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,
                                typename enable_if<__is_exactly_cpp17_input_iterator<_InputIter>::value>::type*)
 {
+  return __insert_with_sentinel(__p, __f, __l);
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {
     __split_buffer<value_type, allocator_type&> __buf(__alloc());
-    __buf.__construct_at_end(__f, __l);
+    __buf.__construct_at_end_with_sentinel(std::move(__f), std::move(__l));
     typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;
     return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
                                typename enable_if<__is_exactly_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
 {
-    size_type __n = _VSTD::distance(__f, __l);
+  return __insert_with_size(__p, __f, std::distance(__f, __l));
+}
+
+template <class _Tp, class _Allocator>
+template <class _Iterator>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_with_size(const_iterator __p, _Iterator __f, size_type __n) {
     __split_buffer<value_type, allocator_type&> __buf(__n, 0, __alloc());
-    __buf.__construct_at_end(__f, __l);
+    __buf.__construct_at_end_with_size(__f, __n);
     typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;
     return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
 }
 
 template <class _Tp, class _Allocator>
 template <class _BiIter>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
                                typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type*)
 {
-    size_type __n = _VSTD::distance(__f, __l);
+  return __insert_bidirectional(__p, __f, __l, std::distance(__f, __l));
+}
+
+template <class _Tp, class _Allocator>
+template <class _BiIter, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel, size_type __n) {
+  return __insert_bidirectional(__p, __f, std::next(__f, __n), __n);
+}
+
+template <class _Tp, class _Allocator>
+template <class _BiIter>
+_LIBCPP_HIDE_FROM_ABI
+typename deque<_Tp, _Allocator>::iterator
+deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n) {
     size_type __pos = __p - begin();
     size_type __to_end = size() - __pos;
     allocator_type& __a = __alloc();
     if (__pos < __to_end)
     {   // insert by shifting things backward
         if (__n > __front_spare())
             __add_front_capacity(__n - __front_spare());
         // __n <= __front_spare()

 }
 
 template <class _Tp, class _Allocator>
 template <class _InpIter>
 void
 deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
                                  typename enable_if<__is_exactly_cpp17_input_iterator<_InpIter>::value>::type*)
 {
+  __append_with_sentinel(__f, __l);
+}
+
+template <class _Tp, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__append_with_sentinel(_InputIterator __f, _Sentinel __l) {
     for (; __f != __l; ++__f)
 #ifdef _LIBCPP_CXX03_LANG
         push_back(*__f);
 #else
         emplace_back(*__f);
 #endif
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForIter>
 void
 deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
                                  typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type*)
 {
-    size_type __n = _VSTD::distance(__f, __l);
+    __append_with_size(__f, std::distance(__f, __l));
+}
+
+template <class _Tp, class _Allocator>
+template <class _InputIterator>
+_LIBCPP_HIDE_FROM_ABI
+void deque<_Tp, _Allocator>::__append_with_size(_InputIterator __f, size_type __n) {
     allocator_type& __a = __alloc();
     size_type __back_capacity = __back_spare();
     if (__n > __back_capacity)
         __add_back_capacity(__n - __back_capacity);
+
     // __n <= __back_capacity
     for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
       _ConstructTransaction __tx(this, __br);
       for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
         __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), *__f);
       }
     }
 }

libcxx/include/queue

public:
 
     queue& operator=(const queue& q) = default;
     queue& operator=(queue&& q) = default;
 
     explicit queue(const container_type& c);
     explicit queue(container_type&& c)
     template<class InputIterator>
         queue(InputIterator first, InputIterator last); // since C++23
+    template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
     template <class Alloc>
         explicit queue(const Alloc& a);
     template <class Alloc>
         queue(const container_type& c, const Alloc& a);
     template <class Alloc>
         queue(container_type&& c, const Alloc& a);
     template <class Alloc>
         queue(const queue& q, const Alloc& a);
     template <class Alloc>
         queue(queue&& q, const Alloc& a);
     template <class InputIterator, class Alloc>
         queue(InputIterator first, InputIterator last, const Alloc&); // since C++23
+    template<container-compatible-range<T> R, class Alloc>
+        queue(from_range_t, R&& rg, const Alloc&); // since C++23
 
     bool      empty() const;
     size_type size() const;
 
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
 
     void push(const value_type& v);
     void push(value_type&& v);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
     void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
 };
 
 template<class Container>
   queue(Container) -> queue<typename Container::value_type, Container>; // C++17
 
 template<class InputIterator>
   queue(InputIterator, InputIterator) -> queue<iter-value-type<InputIterator>>; // since C++23
 
+template<ranges::input_range R>
+  queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
+
 template<class Container, class Allocator>
   queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
 
 template<class InputIterator, class Allocator>
   queue(InputIterator, InputIterator, Allocator)
   -> queue<iter-value-type<InputIterator>,
            deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
 
+template<ranges::input_range R, class Allocator>
+    queue(from_range_t, R&&, Allocator)
+      -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
+
 template <class T, class Container>
   bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
 
 template <class T, class Container>
   bool operator< (const queue<T, Container>& x,const queue<T, Container>& y);
 
 template <class T, class Container>
   bool operator!=(const queue<T, Container>& x,const queue<T, Container>& y);
template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp = Compare());
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, const Container& c);
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, Container&& c);
+    template <container-compatible-range<T> R>
+        priority_queue(from_range_t, R&& rg, const Compare& x = Compare()); // since C++23
     template <class Alloc>
         explicit priority_queue(const Alloc& a);
     template <class Alloc>
         priority_queue(const Compare& comp, const Alloc& a);
     template <class Alloc>
         priority_queue(const Compare& comp, const Container& c,
                        const Alloc& a);
     template <class Alloc>
         priority_queue(const Compare& comp, Container&& c,
                        const Alloc& a);
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Alloc& a);
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, const Alloc& a);
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, const Container& c, const Alloc& a);
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, Container&& c, const Alloc& a);
+    template <container-compatible-range<T> R, class Alloc>
+      priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
+    template <container-compatible-range<T> R, class Alloc>
+      priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
     template <class Alloc>
         priority_queue(const priority_queue& q, const Alloc& a);
     template <class Alloc>
         priority_queue(priority_queue&& q, const Alloc& a);
 
     bool            empty() const;
     size_type       size() const;
     const_reference top() const;
 
     void push(const value_type& v);
     void push(value_type&& v);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
     void swap(priority_queue& q)
         noexcept(is_nothrow_swappable_v<Container> &&
                  is_nothrow_swappable_v<Comp>)
 };
 
 template <class Compare, class Container>
 priority_queue(Compare, Container)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
 
 template<class InputIterator,
          class Compare = less<iter-value-type<InputIterator>>,
          class Container = vector<iter-value-type<InputIterator>>>
 priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
     -> priority_queue<iter-value-type<InputIterator>, Container, Compare>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+  priority_queue(from_range_t, R&&, Compare = Compare())
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
+
 template<class Compare, class Container, class Allocator>
 priority_queue(Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
 
 template<class InputIterator, class Allocator>
 priority_queue(InputIterator, InputIterator, Allocator)
     -> priority_queue<iter-value-type<InputIterator>,
                       vector<iter-value-type<InputIterator>, Allocator>,
                       less<iter-value-type<InputIterator>>>; // C++17
 
 template<class InputIterator, class Compare, class Allocator>
 priority_queue(InputIterator, InputIterator, Compare, Allocator)
     -> priority_queue<iter-value-type<InputIterator>,
                       vector<iter-value-type<InputIterator>, Allocator>, Compare>; // C++17
 
 template<class InputIterator, class Compare, class Container, class Allocator>
 priority_queue(InputIterator, InputIterator, Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
 
+template<ranges::input_range R, class Compare, class Allocator>
+  priority_queue(from_range_t, R&&, Compare, Allocator)
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
+                        Compare>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  priority_queue(from_range_t, R&&, Allocator)
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
+
 template <class T, class Container, class Compare>
   void swap(priority_queue<T, Container, Compare>& x,
             priority_queue<T, Container, Compare>& y)
             noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
 #include <__algorithm/make_heap.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/push_heap.h>
+#include <__algorithm/ranges_copy.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/operations.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <vector>
 #include <version>
 
 // standard-mandated includes
 
 // [queue.syn]
public:
     queue(const queue& __q) : c(__q.c) {}
 
 #if _LIBCPP_STD_VER >= 23
     template <class _InputIterator,
               class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
     _LIBCPP_HIDE_FROM_ABI
     queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
 
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    queue(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
+
     template <class _InputIterator,
               class _Alloc,
               class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
               class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
     _LIBCPP_HIDE_FROM_ABI
     queue(_InputIterator __first, _InputIterator __second, const _Alloc& __alloc) : c(__first, __second, __alloc) {}
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    queue(from_range_t, _Range&& __range, const _Alloc& __alloc)
+      : c(from_range, std::forward<_Range>(__range), __alloc) {}
+
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     queue& operator=(const queue& __q) {c = __q.c; return *this;}
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     queue(queue&& __q)
#endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     const_reference back() const  {return c.back();}
 
     _LIBCPP_INLINE_VISIBILITY
     void push(const value_type& __v) {c.push_back(__v);}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v)      {c.push_back(_VSTD::move(__v));}
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void push_range(_Range&& __range) {
+      if constexpr (requires (container_type& __c) {
+        __c.append_range(std::forward<_Range>(__range));
+      }) {
+        c.append_range(std::forward<_Range>(__range));
+      } else {
+        ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+      }
+    }
+#endif
+
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
 #if _LIBCPP_STD_VER >= 17
         decltype(auto) emplace(_Args&&... __args)
             { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
 #else
         void     emplace(_Args&&... __args)
             {        c.emplace_back(_VSTD::forward<_Args>(__args)...);}

 #endif
 
 #if _LIBCPP_STD_VER >= 23
 template <class _InputIterator,
           class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
 queue(_InputIterator, _InputIterator)
     -> queue<__iter_value_type<_InputIterator>>;
 
+template <ranges::input_range _Range>
+queue(from_range_t, _Range&&)
+    -> queue<ranges::range_value_t<_Range>>;
+
 template <class _InputIterator,
           class _Alloc,
           class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
           class = __enable_if_t<__is_allocator<_Alloc>::value>>
 queue(_InputIterator, _InputIterator, _Alloc)
     -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+
+template <ranges::input_range _Range,
+          class _Alloc,
+          class = __enable_if_t<__is_allocator<_Alloc>::value>>
+queue(from_range_t, _Range&&, _Alloc)
+    -> queue<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
 #endif
 
 template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
 {
     return __x.c == __y.c;
template <class _InputIter, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_CXX03_LANG
     template <class _InputIter, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, container_type&& __c);
 #endif // _LIBCPP_CXX03_LANG
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    priority_queue(from_range_t, _Range&& __range, const value_compare& __comp = value_compare())
+    : c(from_range, std::forward<_Range>(__range)),
+      comp(__comp) {
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+#endif
+
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit priority_queue(const _Alloc& __a,
                        __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(const value_compare& __comp, const _Alloc& __a,
                        __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);

 #ifndef _LIBCPP_CXX03_LANG
     template <class _InputIter, class _Alloc, class = __enable_if_t<__is_cpp17_input_iterator<_InputIter>::value> >
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, container_type&& __c, const _Alloc& __a,
                        __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
 #endif  // _LIBCPP_CXX03_LANG
 
+#if _LIBCPP_STD_VER >= 23
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    priority_queue(from_range_t, _Range&& __range, const value_compare& __comp, const _Alloc& __a)
+    : c(from_range, std::forward<_Range>(__range), __a),
+      comp(__comp) {
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    priority_queue(from_range_t, _Range&& __range, const _Alloc& __a)
+    : c(from_range, std::forward<_Range>(__range), __a),
+      comp() {
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+
+#endif
+
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool            empty() const {return c.empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type       size() const  {return c.size();}
     _LIBCPP_INLINE_VISIBILITY
     const_reference top() const   {return c.front();}
 
     _LIBCPP_INLINE_VISIBILITY
     void push(const value_type& __v);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v);
+
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void push_range(_Range&& __range) {
+      if constexpr (requires (container_type& __c) {
+        __c.append_range(std::forward<_Range>(__range));
+      }) {
+        c.append_range(std::forward<_Range>(__range));
+      } else {
+        ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+      }
+
+      std::make_heap(c.begin(), c.end(), comp);
+    }
+#endif
+
     template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
     void emplace(_Args&&... __args);
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void pop();
 
     _LIBCPP_INLINE_VISIBILITY
template<class _InputIterator, class _Compare, class _Container, class _Alloc,
          class = enable_if_t<!__is_allocator<_Compare>::value>,
          class = enable_if_t<!__is_allocator<_Container>::value>,
          class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
 >
 priority_queue(_InputIterator, _InputIterator, _Compare, _Container, _Alloc)
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range,
+          class _Compare = less<ranges::range_value_t<_Range>>,
+          class = enable_if_t<!__is_allocator<_Compare>::value>>
+priority_queue(from_range_t, _Range&&, _Compare = _Compare())
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>>, _Compare>;
+
+template <ranges::input_range _Range,
+          class _Compare,
+          class _Alloc,
+          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>>
+priority_queue(from_range_t, _Range&&, _Compare, _Alloc)
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>,
+                        _Compare>;
+
+template <ranges::input_range _Range,
+          class _Alloc,
+          class = enable_if_t<__is_allocator<_Alloc>::value>>
+priority_queue(from_range_t, _Range&&, _Alloc)
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>>;
+
+#endif
+
 template <class _Tp, class _Container, class _Compare>
 inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
                                                           const container_type& __c)
     : c(__c),
       comp(__comp)
 {
     _VSTD::make_heap(c.begin(), c.end(), comp);

libcxx/include/stack

public:
     stack(stack&& q) = default;
 
     stack& operator=(const stack& q) = default;
     stack& operator=(stack&& q) = default;
 
     explicit stack(const container_type& c);
     explicit stack(container_type&& c);
     template <class InputIterator> stack(InputIterator first, InputIterator last); // since C++23
+    template<container-compatible-range<T> R> stack(from_range_t, R&& rg); // since C++23
     template <class Alloc> explicit stack(const Alloc& a);
     template <class Alloc> stack(const container_type& c, const Alloc& a);
     template <class Alloc> stack(container_type&& c, const Alloc& a);
     template <class Alloc> stack(const stack& c, const Alloc& a);
     template <class Alloc> stack(stack&& c, const Alloc& a);
     template<class InputIterator, class Alloc>
     stack(InputIterator first, InputIterator last, const Alloc&); // since C++23
+    template<container-compatible-range<T> R, class Alloc>
+      stack(from_range_t, R&& rg, const Alloc&); // since C++23
 
     bool empty() const;
     size_type size() const;
     reference top();
     const_reference top() const;
 
     void push(const value_type& x);
     void push(value_type&& x);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
     void swap(stack& c) noexcept(is_nothrow_swappable_v<Container>)
 };
 
 template<class Container>
   stack(Container) -> stack<typename Container::value_type, Container>;  // C++17
 
 template<class InputIterator>
   stack(InputIterator, InputIterator) -> stack<iter-value-type<InputIterator>>; // since C++23
 
+template<ranges::input_range R>
+  stack(from_range_t, R&&) -> stack<ranges::range_value_t<R>>; // since C++23
+
 template<class Container, class Allocator>
   stack(Container, Allocator) -> stack<typename Container::value_type, Container>; // C++17
 
 template<class InputIterator, class Allocator>
   stack(InputIterator, InputIterator, Allocator)
     -> stack<iter-value-type<InputIterator>,
              deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
 
+template<ranges::input_range R, class Allocator>
+  stack(from_range_t, R&&, Allocator)
+    -> stack<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
+
 template <class T, class Container>
   bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
 
 template <class T, class Container>
   void swap(stack<T, Container>& x, stack<T, Container>& y)
   noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
+#include <__algorithm/ranges_copy.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <version>
 
 // standard-mandated includes
 
 // [stack.syn]

 #endif // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER >= 23
     template <class _InputIterator,
               class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
     _LIBCPP_HIDE_FROM_ABI
     stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
 
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    stack(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
+
     template <class _InputIterator,
               class _Alloc,
               class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
               class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
     _LIBCPP_HIDE_FROM_ABI
     stack(_InputIterator __first, _InputIterator __last, const _Alloc& __alloc) : c(__first, __last, __alloc) {}
+
+    template <_ContainerCompatibleRange<_Tp> _Range,
+              class _Alloc,
+              class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
+    _LIBCPP_HIDE_FROM_ABI
+    stack(from_range_t, _Range&& __range, const _Alloc& __alloc)
+        : c(from_range, std::forward<_Range>(__range), __alloc) {}
+
 #endif
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty()     const      {return c.empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const      {return c.size();}
     _LIBCPP_INLINE_VISIBILITY
     reference top()             {return c.back();}
     _LIBCPP_INLINE_VISIBILITY
     const_reference top() const {return c.back();}
 
     _LIBCPP_INLINE_VISIBILITY
     void push(const value_type& __v) {c.push_back(__v);}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_Tp> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    void push_range(_Range&& __range) {
+      if constexpr (requires (container_type& __c) {
+        __c.append_range(std::forward<_Range>(__range));
+      }) {
+        c.append_range(std::forward<_Range>(__range));
+      } else {
+        ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+      }
+    }
+#endif
+
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
 #if _LIBCPP_STD_VER >= 17
         decltype(auto) emplace(_Args&&... __args)
         { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
 #else
         void      emplace(_Args&&... __args)
         {        c.emplace_back(_VSTD::forward<_Args>(__args)...);}

 #endif
 
 #if _LIBCPP_STD_VER >= 23
 template<class _InputIterator,
          class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
 stack(_InputIterator, _InputIterator)
     -> stack<__iter_value_type<_InputIterator>>;
 
+template <ranges::input_range _Range>
+stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;
+
 template<class _InputIterator,
          class _Alloc,
          class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
          class = __enable_if_t<__is_allocator<_Alloc>::value>>
 stack(_InputIterator, _InputIterator, _Alloc)
     -> stack<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+
+template <ranges::input_range _Range,
+          class _Alloc,
+          class = __enable_if_t<__is_allocator<_Alloc>::value>>
+stack(from_range_t, _Range&&, _Alloc)
+  -> stack<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
+
 #endif
 
 template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
 {
     return __x.c == __y.c;

libcxx/test/std/containers/container.adaptors/from_range_container_adaptors.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_FROM_RANGE_CONTAINER_ADAPTORS_H
+#define SUPPORT_FROM_RANGE_CONTAINER_ADAPTORS_H
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <queue>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "../from_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "test_macros.h"
+#include "unwrap_container_adaptor.h"
+
+template <class Container, class Range>
+concept HasFromRangeCtr = requires (Range&& range) {
+  Container(std::from_range, std::forward<Range>(range));
+  Container(std::from_range, std::forward<Range>(range), std::allocator<typename Container::value_type>());
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints() {
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+template <template <class ...> class Adaptor,
+          template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_container_adaptor_with_input(std::vector<T>&& input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    Adaptor<T> adaptor(std::from_range, in);
+    UnwrapAdaptor<Adaptor<T>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+
+  { // (range, allocator)
+    using C = UnderlyingContainer<T, Alloc>;
+    Alloc alloc;
+    Adaptor<T, C> adaptor(std::from_range, in, alloc);
+    UnwrapAdaptor<Adaptor<T, C>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+}
+
+template <template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+constexpr void test_priority_queue_with_input(std::vector<T>&& input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    std::priority_queue<T> adaptor(std::from_range, in);
+    UnwrapAdaptor<std::priority_queue<T>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+
+  { // (range, comp)
+    using C = UnderlyingContainer<T>;
+    Comp comp;
+
+    std::priority_queue<T, C, Comp> adaptor(std::from_range, in, comp);
+    UnwrapAdaptor<std::priority_queue<T, C, Comp>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+    assert(unwrap_adaptor.get_comparator() == comp);
+  }
+
+  { // (range, allocator)
+    using C = UnderlyingContainer<T, Alloc>;
+    Alloc alloc;
+
+    std::priority_queue<T, C> adaptor(std::from_range, in, alloc);
+    UnwrapAdaptor<std::priority_queue<T, C>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+  }
+
+  { // (range, comp, alloc)
+    using C = UnderlyingContainer<T, Alloc>;
+    Comp comp;
+    Alloc alloc;
+
+    std::priority_queue<T, C, Comp> adaptor(std::from_range, in, comp, alloc);
+    UnwrapAdaptor<std::priority_queue<T, C, Comp>> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::is_permutation(input, c));
+    LIBCPP_ASSERT(c.__invariants());
+    assert(unwrap_adaptor.get_comparator() == comp);
+  }
+}
+
+template <template <class ...> class Adaptor,
+          template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_container_adaptor() {
+  auto test_with_input = &test_container_adaptor_with_input<Adaptor, UnderlyingContainer, T, Iter, Sent, Alloc>;
+
+  // Normal input.
+  test_with_input({0, 5, 12, 7, -1, 8, 26});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({5});
+}
+
+template <template <class ...> class UnderlyingContainer,
+          class T,
+          class Iter,
+          class Sent,
+          class Comp,
+          class Alloc>
+constexpr void test_priority_queue() {
+  auto test_with_input = &test_priority_queue_with_input<UnderlyingContainer, T, Iter, Sent, Comp, Alloc>;
+
+  // Normal input.
+  test_with_input({0, 5, 12, 7, -1, 8, 26});
+  // Empty input.
+  test_with_input({});
+  // Single-element input.
+  test_with_input({5});
+}
+
+template <template <class ...> class Container>
+constexpr void test_container_adaptor_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  [[maybe_unused]] Container<MoveOnly> c(std::from_range, in);
+}
+
+template <template <class ...> class Adaptor>
+void test_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Adaptor<T, std::vector<T>> c(std::from_range, in);
+    assert(false); // The constructor call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Adaptor, class T>
+void test_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    using C = std::vector<T, ThrowingAllocator<T>>;
+    ThrowingAllocator<T> alloc;
+
+    globalMemCounter.reset();
+    Adaptor<T, C> c(std::from_range, in, alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_FROM_RANGE_CONTAINER_ADAPTORS_H

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp

 //          class Compare = less<typename iterator_traits<InputIterator>::value_type>,
 //          class Container = vector<typename iterator_traits<InputIterator>::value_type>>
 // priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
 //     -> priority_queue<typename iterator_traits<InputIterator>::value_type, Container, Compare>;
 //
 // template<class Compare, class Container, class Allocator>
 // priority_queue(Compare, Container, Allocator)
 //     -> priority_queue<typename Container::value_type, Container, Compare>;
+//
+// template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+//   priority_queue(from_range_t, R&&, Compare = Compare())
+//     -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
+//
+// template<ranges::input_range R, class Compare, class Allocator>
+//   priority_queue(from_range_t, R&&, Compare, Allocator)
+//     -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
+//                         Compare>; // C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   priority_queue(from_range_t, R&&, Allocator)
+//     -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
 
-
-#include <queue>
-#include <vector>
-#include <iterator>
 #include <cassert>
-#include <cstddef>
 #include <climits> // INT_MAX
+#include <cstddef>
+#include <iterator>
+#include <queue>
+#include <vector>
 
 #include "deduction_guides_sfinae_checks.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 
 struct A {};
 
assert(pri.size() == 0);
         }
 
         {
         Cont cont;
         ConvertibleToT a[2] = {};
         std::priority_queue pri(a, a+2, Comp(), std::move(cont), ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(pri), std::priority_queue<T, Cont, Comp>>);
         }
+
+#if TEST_STD_VER >= 23
+        { // (from_range, range)
+          std::priority_queue c(std::from_range, Cont());
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T>>);
+        }
+
+        { // (from_range, range, compare)
+          std::priority_queue c(std::from_range, Cont(), Comp());
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T, std::vector<T>, Comp>>);
+        }
+
+        { // (from_range, range, compare, alloc)
+          std::priority_queue c(std::from_range, Cont(), Comp(), Alloc(2));
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T, std::vector<T, Alloc>, Comp>>);
+        }
+
+        { // (from_range, range, alloc)
+          std::priority_queue c(std::from_range, Cont(), Alloc(2));
+          static_assert(std::is_same_v<decltype(c), std::priority_queue<T, std::vector<T, Alloc>>>);
+        }
+#endif // TEST_STD_VER >= 23
     }
 
     // Deduction guides should be SFINAE'd away when given:
     // - "bad" input iterators (that is, a type not qualifying as an input
     //   iterator);
     // - a bad allocator;
     // - an allocator instead of a comparator;
     // - an allocator instead of a container;
#endif // _LIBCPP_VERSION
         static_assert(SFINAEs_away<std::priority_queue, Comp, Cont, DiffAlloc>);
 
         // (comp, cont)
         //
         // Cannot deduce from (ALLOC_as_comp, cont)
         static_assert(SFINAEs_away<std::priority_queue, AllocAsComp, Cont>);
         // Cannot deduce from (comp, ALLOC_as_cont)
         static_assert(SFINAEs_away<std::priority_queue, Comp, AllocAsCont>);
+
+#if TEST_STD_VER >= 23
+        using Range = RangeT<int>;
+        using BadRange = BadRangeT<int>;
+
+        // (from_range, range)
+        //
+        // Cannot deduce from (from_range, BAD_range)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange>);
+
+        // (from_range, range, compare)
+        //
+        // Cannot deduce from (from_range, BAD_range, compare)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange, Comp>);
+
+        // (from_range, range, compare, alloc)
+        //
+        // Cannot deduce from (from_range, BAD_range, compare, alloc)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange, Comp, Alloc>);
+        // Cannot deduce from (from_range, range, compare, BAD_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, Comp, BadAlloc>);
+        // Cannot deduce from (from_range, range, compare, DIFFERENT_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, Comp, DiffAlloc>);
+
+        // (from_range, range, alloc)
+        //
+        // Cannot deduce from (from_range, BAD_range, alloc)
+        static_assert(SFINAEs_away<std::priority_queue, BadRange, Alloc>);
+        // Cannot deduce from (from_range, range, BAD_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, BadAlloc>);
+        // Cannot deduce from (from_range, range, DIFFERENT_alloc)
+        static_assert(SFINAEs_away<std::priority_queue, Range, DiffAlloc>);
+#endif // TEST_STD_VER >= 23
     }
 
     return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/from_range.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <queue>
+
+#include "../../from_range_container_adaptors.h"
+#include "../../../test_compare.h"
+#include "test_macros.h"
+
+// template <container-compatible-range<T> R>
+//   priority_queue(from_range_t, R&& rg, const Compare& x = Compare()); // since C++23
+// template <container-compatible-range<T> R, class Alloc>
+//   priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
+// template <container-compatible-range<T> R, class Alloc>
+//   priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
+
+template <class Range>
+concept PriorityQueueHasFromRangeCtr = requires (Range&& range) {
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range));
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range), std::less<int>());
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range), std::less<int>(), std::allocator<int>());
+  std::priority_queue<int>(std::from_range, std::forward<Range>(range), std::allocator<int>());
+};
+
+constexpr bool test_constraints_priority_queue() {
+  // Input range with the same value type.
+  static_assert(PriorityQueueHasFromRangeCtr<InputRange<int>>);
+  // Input range with a convertible value type.
+  static_assert(PriorityQueueHasFromRangeCtr<InputRange<double>>);
+  // Input range with a non-convertible value type.
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRangeNotDerivedFrom>);
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRangeNotIndirectlyReadable>);
+  static_assert(!PriorityQueueHasFromRangeCtr<InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_priority_queue<std::vector, int, Iter, Sent, test_less<int>, Alloc>();
+  });
+  test_container_adaptor_move_only<std::priority_queue>();
+
+  static_assert(test_constraints_priority_queue());
+
+  test_exception_safety_throwing_copy<std::priority_queue>();
+  test_exception_safety_throwing_allocator<std::priority_queue, int>();
+
+  return 0;
+}

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.members/push_range.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<container-compatible-range<T> R>
+//   void push_range(R&& rg); // C++23
+
+#include <queue>
+
+#include "../../push_range_container_adaptors.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_push_range<std::priority_queue<int, std::vector<int, Alloc>>, Iter, Sent>(/*is_result_heapified=*/true);
+  });
+  test_push_range_move_only<std::priority_queue>();
+  test_push_range_inserter_choice<std::priority_queue, int>(/*is_result_heapified=*/true);
+
+  static_assert(test_constraints_push_range<std::priority_queue, int, double>());
+
+  test_push_range_exception_safety_throwing_copy<std::priority_queue>();
+  test_push_range_exception_safety_throwing_allocator<std::priority_queue, std::vector, int>();
+
+  return 0;
+}
+

libcxx/test/std/containers/container.adaptors/push_range_container_adaptors.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_PUSH_RANGE_CONTAINER_ADAPTORS_H
+#define SUPPORT_PUSH_RANGE_CONTAINER_ADAPTORS_H
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include <initializer_list>
+#include <ranges>
+#include <type_traits>
+#include <vector>
+
+#include "../from_range_helpers.h"
+#include "../insert_range_helpers.h"
+#include "MoveOnly.h"
+#include "almost_satisfies_types.h"
+#include "count_new.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "unwrap_container_adaptor.h"
+
+template <class Container, class Range>
+concept HasPushRange = requires (Container& c, Range&& range) {
+  c.push_range(range);
+};
+
+template <template <class...> class Container, class T, class U>
+constexpr bool test_constraints_push_range() {
+  // Input range with the same value type.
+  static_assert(HasPushRange<Container<T>, InputRange<T>>);
+  // Input range with a convertible value type.
+  static_assert(HasPushRange<Container<T>, InputRange<U>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasPushRange<Container<T>, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasPushRange<Container<T>, InputRangeNotDerivedFrom>);
+  static_assert(!HasPushRange<Container<T>, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasPushRange<Container<T>, InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+// Empty container.
+
+template <class T>
+TestCase<T> constexpr EmptyContainer_EmptyRange {
+  .initial = {}, .input = {}, .expected = {}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_OneElementRange {
+  .initial = {}, .input = {5}, .expected = {5}
+};
+
+template <class T> constexpr TestCase<T> EmptyContainer_MidRange {
+  .initial = {}, .input = {5, 3, 1, 7, 9}, .expected = {5, 3, 1, 7, 9}
+};
+
+// One-element container.
+
+template <class T> constexpr TestCase<T> OneElementContainer_EmptyRange {
+  .initial = {3}, .input = {}, .expected = {3}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_OneElementRange {
+  .initial = {3}, .input = {-5}, .expected = {3, -5}
+};
+
+template <class T> constexpr TestCase<T> OneElementContainer_MidRange {
+  .initial = {3}, .input = {-5, -3, -1, -7, -9}, .expected = {3, -5, -3, -1, -7, -9}
+};
+
+// Full container.
+
+template <class T> constexpr TestCase<T> FullContainer_EmptyRange {
+  .initial = {11, 29, 35, 14, 84}, .input = {}, .expected = {11, 29, 35, 14, 84}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_OneElementRange {
+  .initial = {11, 29, 35, 14, 84}, .input = {-5}, .expected = {11, 29, 35, 14, 84, -5}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_MidRange {
+  .initial = {11, 29, 35, 14, 84},
+  .input = {-5, -3, -1, -7, -9},
+  .expected = {11, 29, 35, 14, 84, -5, -3, -1, -7, -9}
+};
+
+template <class T> constexpr TestCase<T> FullContainer_LongRange {
+  .initial = {11, 29, 35, 14, 84},
+  .input = {-5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48},
+  .expected = {
+      11, 29, 35, 14, 84, -5, -3, -1, -7, -9, -19, -48, -56, -13, -14, -29, -88, -17, -1, -5, -11, -89, -21, -33, -48
+  }
+};
+
+// Container adaptors tests.
+
+template <class Adaptor, class Iter, class Sent>
+constexpr void test_push_range(bool is_result_heapified = false) {
+  using T = typename Adaptor::value_type;
+
+  auto test = [&](auto& test_case) {
+    Adaptor adaptor(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+
+    adaptor.push_range(in);
+    UnwrapAdaptor<Adaptor> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+
+    if (is_result_heapified) {
+      assert(std::ranges::is_heap(c));
+      return std::ranges::is_permutation(c, test_case.expected);
+    } else {
+      return std::ranges::equal(c, test_case.expected);
+    }
+  };
+
+  { // Empty container.
+    // empty_c.push_range(empty_range)
+    assert(test(EmptyContainer_EmptyRange<T>));
+    // empty_c.push_range(one_element_range)
+    assert(test(EmptyContainer_OneElementRange<T>));
+    // empty_c.push_range(mid_range)
+    assert(test(EmptyContainer_MidRange<T>));
+  }
+
+  { // One-element container.
+    // one_element_c.push_range(empty_range)
+    assert(test(OneElementContainer_EmptyRange<T>));
+    // one_element_c.push_range(one_element_range)
+    assert(test(OneElementContainer_OneElementRange<T>));
+    // one_element_c.push_range(mid_range)
+    assert(test(OneElementContainer_MidRange<T>));
+  }
+
+  { // Full container.
+    // full_container.push_range(empty_range)
+    assert(test(FullContainer_EmptyRange<T>));
+    // full_container.push_range(one_element_range)
+    assert(test(FullContainer_OneElementRange<T>));
+    // full_container.push_range(mid_range)
+    assert(test(FullContainer_MidRange<T>));
+    // full_container.push_range(long_range)
+    assert(test(FullContainer_LongRange<T>));
+  }
+}
+
+// Move-only types.
+
+template <template <class ...> class Container>
+constexpr void test_push_range_move_only() {
+  MoveOnly input[5];
+  std::ranges::subrange in(std::move_iterator(input), std::move_iterator(input + 5));
+
+  Container<MoveOnly> c;
+  c.push_range(in);
+}
+
+// Check that `append_range` is preferred if available and `push_back` is used as a fallback.
+
+enum class InserterChoice {
+  Invalid,
+  PushBack,
+  AppendRange
+};
+
+template <class T, InserterChoice Inserter>
+struct Container {
+  InserterChoice inserter_choice = InserterChoice::Invalid;
+
+  using value_type = T;
+  using iterator = T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = std::size_t;
+
+  static constexpr int Capacity = 8;
+  int size_ = 0;
+  value_type buffer_[Capacity] = {};
+
+  iterator begin() { return buffer_; }
+  iterator end() { return buffer_ + size_; }
+  size_type size() const { return size_; }
+
+  template <class U>
+  void push_back(U val)
+  requires (Inserter >= InserterChoice::PushBack) {
+    inserter_choice = InserterChoice::PushBack;
+    buffer_[size_] = val;
+    ++size_;
+  }
+
+  template <std::ranges::input_range Range>
+  void append_range(Range&& range)
+  requires (Inserter >= InserterChoice::AppendRange) {
+    assert(size() + std::ranges::distance(range) <= Capacity);
+
+    inserter_choice = InserterChoice::AppendRange;
+
+    for (auto&& e : range) {
+      buffer_[size_] = e;
+      ++size_;
+    }
+  }
+
+  friend bool operator==(const Container&, const Container&) = default;
+};
+
+template <template <class ...> class AdaptorT, class T>
+void test_push_range_inserter_choice(bool is_result_heapified = false) {
+  { // `append_range` is preferred if available.
+    using BaseContainer = Container<T, InserterChoice::AppendRange>;
+    using Adaptor = AdaptorT<T, BaseContainer>;
+    T in[] = {1, 2, 3, 4, 5};
+
+    Adaptor adaptor;
+    adaptor.push_range(in);
+
+    UnwrapAdaptor<Adaptor> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+    assert(c.inserter_choice == InserterChoice::AppendRange);
+    if (is_result_heapified) {
+      assert(std::ranges::is_heap(c));
+      assert(std::ranges::is_permutation(c, in));
+    } else {
+      assert(std::ranges::equal(c, in));
+    }
+  }
+
+  { // `push_back` is used as a fallback (via `back_inserter`).
+    using BaseContainer = Container<T, InserterChoice::PushBack>;
+    using Adaptor = AdaptorT<T, BaseContainer>;
+    T in[] = {1, 2, 3, 4, 5};
+
+    Adaptor adaptor;
+    adaptor.push_range(in);
+
+    UnwrapAdaptor<Adaptor> unwrap_adaptor(std::move(adaptor));
+    auto& c = unwrap_adaptor.get_container();
+    assert(c.inserter_choice == InserterChoice::PushBack);
+    if (is_result_heapified) {
+      assert(std::ranges::is_heap(c));
+      assert(std::ranges::is_permutation(c, in));
+    } else {
+      assert(std::ranges::equal(c, in));
+    }
+  }
+}
+
+// Exception safety.
+
+template <template <class ...> class Container>
+void test_push_range_exception_safety_throwing_copy() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  using T = ThrowingCopy<3>;
+  T::reset();
+  T in[5];
+
+  try {
+    Container<T> c;
+    c.push_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(T::created_by_copying == 3);
+    assert(T::destroyed == 2); // No destructor call for the partially-constructed element.
+  }
+#endif
+}
+
+template <template <class ...> class Adaptor, template <class ...> class BaseContainer, class T>
+void test_push_range_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  T in[] = {0, 1};
+
+  try {
+    globalMemCounter.reset();
+    Adaptor<T, BaseContainer<T, ThrowingAllocator<T>>> c;
+    c.push_range(in);
+    assert(false); // The function call above should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+#endif // SUPPORT_PUSH_RANGE_CONTAINER_ADAPTORS_H

libcxx/test/std/containers/container.adaptors/queue/queue.cons/deduct.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
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template<class Container>
 //   queue(Container) -> queue<typename Container::value_type, Container>;
 //
 // template<class Container, class Allocator>
 //   queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
-
+//
+// template<ranges::input_range R>
+//   queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
+//
+// template<ranges::input_range R, class Allocator>
+//     queue(from_range_t, R&&, Allocator)
+//       -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
 
 #include <array>
 #include <queue>
 #include <list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
assert(que.size() == 0);
 
         {
         std::queue<T, Cont> source;
         std::queue que(std::move(source), ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(que), std::queue<T, Cont>>);
         }
     }
 
-    // Deduction guides should be SFINAE'd away when given:
-    // - a "bad" allocator (that is, a type not qualifying as an allocator);
-    // - an allocator instead of a container;
-    // - an allocator and a container that uses a different allocator.
-    {
-        using Cont = std::list<int>;
-        using Alloc = std::allocator<int>;
-        using DiffAlloc = test_allocator<int>;
-        using Iter = int*;
-
-        struct NotIter{};
-        struct NotAlloc {};
-
-        static_assert(SFINAEs_away<std::queue, Alloc, NotAlloc>);
-        static_assert(SFINAEs_away<std::queue, Cont, NotAlloc>);
-        static_assert(SFINAEs_away<std::queue, Cont, DiffAlloc>);
-        static_assert(SFINAEs_away<std::queue, Iter, NotIter>);
-#if TEST_STD_VER > 20
-        static_assert(SFINAEs_away<std::queue, Iter, NotIter, Alloc>);
-        static_assert(SFINAEs_away<std::queue, Iter, Iter, NotAlloc>);
-#endif
-    }
-#if TEST_STD_VER > 20
+#if TEST_STD_VER >= 23
     {
         typedef short T;
         typedef test_allocator<T> Alloc;
         std::list<T> a;
         {
         std::queue q(a.begin(), a.end());
         static_assert(std::is_same_v<decltype(q), std::queue<T>>);
         }
         {
         std::queue q(a.begin(), a.end(), Alloc());
         static_assert(std::is_same_v<decltype(q), std::queue<T, std::deque<T, Alloc>>>);
         }
     }
+
+    {
+      {
+        std::queue c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::queue<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::queue c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::queue<int, std::deque<int, Alloc>>>);
+      }
+    }
 #endif
+
+    ContainerAdaptorDeductionGuidesSfinaeAway<std::queue, std::queue<int>>();
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.cons/from_range.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <queue>
+
+#include "../../from_range_container_adaptors.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
+// template<container-compatible-range<T> R, class Alloc>
+//   queue(from_range_t, R&& rg, const Alloc&); // since C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_container_adaptor<std::queue, std::deque, int, Iter, Sent, Alloc>();
+  });
+  test_container_adaptor_move_only<std::queue>();
+
+  static_assert(test_constraints<std::queue, int, double>());
+
+  test_exception_safety_throwing_copy<std::queue>();
+  test_exception_safety_throwing_allocator<std::queue, int>();
+
+  return 0;
+}

libcxx/test/std/containers/container.adaptors/queue/queue.defn/push_range.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<container-compatible-range<T> R>
+//   void push_range(R&& rg); // C++23
+
+#include <queue>
+
+#include "../../push_range_container_adaptors.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_push_range<std::queue<int, std::deque<int, Alloc>>, Iter, Sent>();
+  });
+  test_push_range_move_only<std::queue>();
+  test_push_range_inserter_choice<std::queue, int>();
+
+  static_assert(test_constraints_push_range<std::queue, int, double>());
+
+  test_push_range_exception_safety_throwing_copy<std::queue>();
+  test_push_range_exception_safety_throwing_allocator<std::queue, std::deque, int>();
+
+  return 0;
+}

libcxx/test/std/containers/container.adaptors/stack/stack.cons/deduct.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
 //
 //===----------------------------------------------------------------------===//
 
 // <stack>
 // UNSUPPORTED: c++03, c++11, c++14
 
 // template<class Container>
 //   stack(Container) -> stack<typename Container::value_type, Container>;
 //
 // template<class Container, class Allocator>
 //   stack(Container, Allocator) -> stack<typename Container::value_type, Container>;
-
+//
+// template<ranges::input_range R>
+//   stack(from_range_t, R&&) -> stack<ranges::range_value_t<R>>; // since C++23
+//
+// template<ranges::input_range R, class Allocator>
+//   stack(from_range_t, R&&, Allocator)
+//     -> stack<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
 
 #include <array>
 #include <stack>
 #include <deque>
 #include <vector>
 #include <list>
 #include <iterator>
 #include <cassert>
assert(stk.size() == 0);
 
         {
         std::stack<T, Cont> source;
         std::stack stk(std::move(source), ConvertibleToAlloc(2));
         static_assert(std::is_same_v<decltype(stk), std::stack<T, Cont>>);
         }
     }
 
-    // Deduction guides should be SFINAE'd away when given:
-    // - a "bad" allocator (that is, a type not qualifying as an allocator);
-    // - an allocator instead of a container;
-    // - an allocator and a container that uses a different allocator.
-    {
-        using Cont = std::list<int>;
-        using Alloc = std::allocator<int>;
-        using DiffAlloc = test_allocator<int>;
-        using Iter = int;
-
-        struct NotIter {};
-        struct NotAlloc {};
-
-        static_assert(SFINAEs_away<std::stack, Alloc, Alloc>);
-        static_assert(SFINAEs_away<std::stack, Cont, NotAlloc>);
-        static_assert(SFINAEs_away<std::stack, Cont, DiffAlloc>);
-        static_assert(SFINAEs_away<std::stack, Iter, NotIter>);
-#if TEST_STD_VER > 20
-        static_assert(SFINAEs_away<std::stack, Iter, NotIter, Alloc>);
-        static_assert(SFINAEs_away<std::stack, Iter, Iter, NotAlloc>);
-#endif
-    }
-
-#if TEST_STD_VER > 20
+#if TEST_STD_VER >= 23
     {
         typedef short T;
         typedef test_allocator<T> Alloc;
         std::list<T> a;
         {
         std::stack s(a.begin(), a.end());
         static_assert(std::is_same_v<decltype(s), std::stack<T>>);
         }
         {
         std::stack s(a.begin(), a.end(), Alloc());
         static_assert(std::is_same_v<decltype(s), std::stack<T, std::deque<T, Alloc>>>);
         }
     }
+
+    {
+      {
+        std::stack c(std::from_range, std::array<int, 0>());
+        static_assert(std::is_same_v<decltype(c), std::stack<int>>);
+      }
+
+      {
+        using Alloc = test_allocator<int>;
+        std::stack c(std::from_range, std::array<int, 0>(), Alloc());
+        static_assert(std::is_same_v<decltype(c), std::stack<int, std::deque<int, Alloc>>>);
+      }
+    }
 #endif
 
+    ContainerAdaptorDeductionGuidesSfinaeAway<std::stack, std::stack<int>>();
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.cons/from_range.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <stack>
+
+#include "../../from_range_container_adaptors.h"
+#include "test_macros.h"
+
+// template<container-compatible-range<T> R> stack(from_range_t, R&& rg); // since C++23
+// template<container-compatible-range<T> R, class Alloc>
+//   stack(from_range_t, R&& rg, const Alloc&); // since C++23
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int>([]<class Iter, class Sent, class Alloc>() {
+    test_container_adaptor<std::stack, std::deque, int, Iter, Sent, Alloc>();
+  });
+  test_container_adaptor_move_only<std::stack>();
+
+  static_assert(test_constraints<std::stack, int, double>());
+
+  test_exception_safety_throwing_copy<std::stack>();
+  test_exception_safety_throwing_allocator<std::stack, int>();
+
+  return 0;
+}

libcxx/test/std/containers/container.adaptors/stack/stack.defn/push_range.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<container-compatible-range<T> R>
+//   void push_range(R&& rg); // C++23
+
+#include <stack>
+
+#include "../../push_range_container_adaptors.h"
+#include "test_macros.h"
+
+int main(int, char**) {
+  for_all_iterators_and_allocators<int, const int*>([]<class Iter, class Sent, class Alloc>() {
+    test_push_range<std::stack<int, std::deque<int, Alloc>>, Iter, Sent>();
+  });
+  test_push_range_move_only<std::stack>();
+  test_push_range_inserter_choice<std::stack, int>();
+
+  static_assert(test_constraints_push_range<std::stack, int, double>());
+
+  test_push_range_exception_safety_throwing_copy<std::stack>();
+  test_push_range_exception_safety_throwing_allocator<std::stack, std::deque, int>();
+
+  return 0;
+}

libcxx/test/support/deduction_guides_sfinae_checks.h

#if TEST_STD_VER >= 23
 
   // (from_range, range, alloc)
   //
   // Cannot deduce from (range, BAD_alloc)
   static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
 #endif
 }
 
+// Deduction guides should be SFINAE'd away when given:
+// - a "bad" allocator (that is, a type not qualifying as an allocator);
+// - an allocator instead of a container;
+// - an allocator and a container that uses a different allocator;
+// - a range not satisfying the `input_range` concept.
+template<template<typename ...> class Container, typename InstantiatedContainer>
+constexpr void ContainerAdaptorDeductionGuidesSfinaeAway() {
+  using T = typename InstantiatedContainer::value_type;
+  using Alloc = std::allocator<T>;
+  using Iter = T*;
+
+  using BadIter = int;
+  using BadAlloc = Empty;
+
+  // (container) -- no constraints.
+
+  // (container, alloc)
+  //
+  // Cannot deduce from (container, BAD_alloc)
+  static_assert(SFINAEs_away<Container, std::vector<T>, BadAlloc>);
+
+  // (iter, iter)
+  //
+  // Cannot deduce from (BAD_iter, BAD_iter)
+  LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter>);
+
+#if TEST_STD_VER >= 23
+  using BadRange = BadRangeT<T>;
+
+  // (iter, iter, alloc)
+  //
+  // Cannot deduce from (BAD_iter, BAD_iter, alloc)
+  LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter, Alloc>);
+  // Cannot deduce from (iter, iter, BAD_alloc)
+  static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);
+
+  // (from_range, range)
+  //
+  // Cannot deduce from (BAD_range)
+  static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
+
+  // (from_range, range, alloc)
+  //
+  // Cannot deduce from (range, BAD_alloc)
+  static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
+#endif
+}
+
 // For associative containers the deduction guides should be SFINAE'd away when
 // given:
 // - "bad" input iterators (that is, a type not qualifying as an input
 //   iterator);
 // - a bad allocator;
 // - an allocator in place of a comparator.
 
 template<template<typename ...> class Container, typename InstantiatedContainer>

libcxx/test/support/unwrap_container_adaptor.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_UNWRAP_CONTAINER_ADAPTOR_H
+#define SUPPORT_UNWRAP_CONTAINER_ADAPTOR_H
+
+// Allows accessing the underlying container of the given adaptor.
+template <class Adaptor>
+struct UnwrapAdaptor : Adaptor {
+  UnwrapAdaptor() = default;
+
+  UnwrapAdaptor(Adaptor&& adaptor) : Adaptor(std::move(adaptor)) {}
+  // `c` is a protected member variable of the base class.
+  decltype(auto) get_container() {
+    return (UnwrapAdaptor::c); // Put into parentheses to make sure the function returns a reference.
+  }
+
+  // TODO: make this work pre-C++20.
+  decltype(auto) get_comparator()
+  requires requires {
+    UnwrapAdaptor::c;
+  } {
+    return (UnwrapAdaptor::comp); // Put into parentheses to make sure the function returns a reference.
+  }
+};
+
+#endif // SUPPORT_UNWRAP_CONTAINER_ADAPTOR_H