[libc++] Implement the resolutions for LWG3506 and LWG3522.

[• Quuxplusone]

Summary

Implement the changes in all language modes.

LWG3506 "Missing allocator-extended constructors for priority_queue"
makes the following changes:
- New allocator-extended constructors for priority_queue.
- New deduction guides targeting those constructors.

LWG3522: "Missing requirement on InputIterator template parameter
for priority_queue constructors". The iterator parameter should be
constrained to actually be an iterator type. `priority_queue{1,2}`
should be SFINAE-friendly ill-formed.

Also, do a drive-by fix in the allocator-extended move constructor:
there's no need to do a `make_heap` after moving from `__q.c` into
our own `c`, because that container was already heapified when it
was part of `__q`. [priqueue.cons.alloc] actually specifies the
behavior and does *not* mention calling `make_heap`. I think this
was just a copy-paste thinko. It dates back to the initial import
of libc++.

[• Quuxplusone]

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

21

I had initially written this test as follows, to test SFINAE-friendliness; but during the rebase I temporarily forgot why I'd done that, and changed it to the much simpler (but not-testing-SFINAE) version you see above. If you want me to change back to the SFINAE version, I can.

template<class Seq>
std::true_type test(int, decltype(Seq(1,2))) { return {}; }

template<class Seq>
std::false_type test(long, Seq) { return {}; }

int main(int, char**)
{
    // Sanity-check that std::vector<int>(1,2) is well-formed.
    auto vector_is_constructible = test< std::vector<int> >(1, {});
    static_assert(decltype(vector_is_constructible)::value, "");

    // LWG3522: std::priority_queue<int>(1,2) is NOT well-formed.
    auto pq_is_constructible = test< std::priority_queue<int> >(1, {});
    static_assert(!decltype(pq_is_constructible)::value, "");

    return 0;
}

[ldionne]

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

18

You're missing tests for some of the constructors you modified, aren't you?

[• Quuxplusone]

Roll D106824 into D106827. Add is_constructible tests also for the new constructors added in D106824.

[• Quuxplusone]

Landed as part of rG3894a8a4768f

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

18

Yes; initially this was just a sanity-check to make sure that e.g.
std::priority_queue<int> pq = {1,2}; // or maybe more ints
didn't compile, even though it would compile fine for std::vector.
But adding the other signatures is easy, so done.

libcxx/docs/Status/Cxx2bIssues.csv

 `3462 <https://wg21.link/LWG3462>`__,"§[formatter.requirements]: Formatter requirements forbid use of ``fc.arg()``","June 2021","",""
 `3481 <https://wg21.link/LWG3481>`__,"``viewable_range`` mishandles lvalue move-only views","June 2021","",""
 `3506 <https://wg21.link/LWG3506>`__,"Missing allocator-extended constructors for ``priority_queue``","June 2021","|Complete|","13.0"
 `3517 <https://wg21.link/LWG3517>`__,"``join_view::iterator``'s ``iter_swap`` is underconstrained","June 2021","",""
 `3518 <https://wg21.link/LWG3518>`__,"Exception requirements on char trait operations unclear","June 2021","",""
 `3519 <https://wg21.link/LWG3519>`__,"Incomplete synopses for <random> classes","June 2021","",""
 `3520 <https://wg21.link/LWG3520>`__,"``iter_move`` and ``iter_swap`` are inconsistent for ``transform_view::iterator``","June 2021","",""
 `3521 <https://wg21.link/LWG3521>`__,"Overly strict requirements on ``qsort`` and ``bsearch``","June 2021","",""
-`3522 <https://wg21.link/LWG3522>`__,"Missing requirement on ``InputIterator`` template parameter for ``priority_queue`` constructors","June 2021","",""
+`3522 <https://wg21.link/LWG3522>`__,"Missing requirement on ``InputIterator`` template parameter for ``priority_queue`` constructors","June 2021","|Complete|","13.0"
 `3523 <https://wg21.link/LWG3523>`__,"``iota_view::sentinel`` is not always ``iota_view``'s sentinel","June 2021","",""
 `3526 <https://wg21.link/LWG3526>`__,"Return types of ``uses_allocator_construction_args`` unspecified","June 2021","",""
 `3527 <https://wg21.link/LWG3527>`__,"``uses_allocator_construction_args`` handles rvalue pairs of rvalue references incorrectly","June 2021","",""
 `3528 <https://wg21.link/LWG3528>`__,"``make_from_tuple`` can perform (the equivalent of) a C-style cast","June 2021","",""
 `3529 <https://wg21.link/LWG3529>`__,"``priority_queue(first, last)`` should construct ``c`` with ``(first, last)``","June 2021","",""
 `3530 <https://wg21.link/LWG3530>`__,"``BUILTIN-PTR-MEOW`` should not opt the type out of syntactic checks","June 2021","",""
 `3532 <https://wg21.link/LWG3532>`__,"``split_view<V, P>::inner-iterator<true>::operator++(int)`` should depend on ``Base``","June 2021","",""
 `3533 <https://wg21.link/LWG3533>`__,"Make ``base() const &`` consistent across iterator wrappers that supports ``input_iterators``","June 2021","",""

libcxx/docs/Status/RangesIssues.csv

-"Number","Name","Status","Assignee"
+"Number","Name","Status","First released version"
 `P0896R4 <https://wg21.link/P0896R4>`__,<ranges>,,
 `P1035R7 <https://wg21.link/P1035R7>`__,Input Range Adaptors,,
 `P1207R4 <https://wg21.link/P1207R4>`__,Movability Of Single-Pass Iterators,,
 `P1243R4 <https://wg21.link/P1243R4>`__,Rangify New Algorithms,,
 `P1248R1 <https://wg21.link/P1248R1>`__,Fixing Relations,,
 `P1252R2 <https://wg21.link/P1252R2>`__,Ranges Design Cleanup,,
 `P1391R4 <https://wg21.link/P1391R4>`__,Range Constructor For string_view,,
 `P1456R1 <https://wg21.link/P1456R1>`__,Move-Only Views,,

 `LWG3397 <https://wg21.link/lwg3397>`__, ranges::basic_istream_view::iterator should not provide iterator_category,,
 `LWG3398 <https://wg21.link/lwg3398>`__, tuple_element_t is also wrong for const subrange,,
 `LWG3474 <https://wg21.link/lwg3474>`__, Nesting join_views is broken because of CTAD,,
 `LWG3481 <https://wg21.link/LWG3481>`__,"viewable_range mishandles lvalue move-only views",,
 `LWG3500 <https://wg21.link/lwg3500>`__, join_view::iterator::operator->() is bogus,,
 `LWG3505 <https://wg21.link/lwg3505>`__, split_view::outer-iterator::operator++ misspecified,,
 `LWG3517 <https://wg21.link/LWG3517>`__,"join_view::iterator's iter_swap is underconstrained",,
 `LWG3520 <https://wg21.link/LWG3520>`__,"iter_move and iter_swap are inconsistent for transform_view::iterator",,
-`LWG3522 <https://wg21.link/LWG3522>`__,"Missing requirement on InputIterator template parameter for priority_queue constructors",,
+`LWG3522 <https://wg21.link/LWG3522>`__,"Missing requirement on InputIterator template parameter for priority_queue constructors","Complete","13.0"
 `LWG3523 <https://wg21.link/LWG3523>`__,"iota_view::sentinel is not always iota_view's sentinel",,
 `LWG3532 <https://wg21.link/LWG3532>`__,"split_view<V, P>::inner-iterator<true>::operator++(int) should depend on Base",,
 `LWG3533 <https://wg21.link/LWG3533>`__,"Make base() const & consistent across iterator wrappers that supports input_iterators",,
 `LWG3541 <https://wg21.link/LWG3541>`__,"indirectly_readable_traits should be SFINAE-friendly for all types",,
 `LWG3543 <https://wg21.link/LWG3543>`__,"Definition of when counted_iterators refer to the same sequence isn't quite right",,
 `LWG3546 <https://wg21.link/LWG3546>`__,"common_iterator's postfix-proxy is not quite right",,
 `LWG3549 <https://wg21.link/LWG3549>`__,"view_interface is overspecified to derive from view_base",,
 `LWG3551 <https://wg21.link/LWG3551>`__,"borrowed_{iterator,subrange}_t are overspecified",,
 `LWG3553 <https://wg21.link/LWG3553>`__,"Useless constraint in split_view::outer-iterator::value_type::begin()",,
 `LWG3555 <https://wg21.link/LWG3555>`__,"{transform,elements}_view::iterator::iterator_concept should consider const-qualification of the underlying range",,

libcxx/include/queue

#endif // _LIBCPP_CXX03_LANG
     explicit priority_queue(const value_compare& __comp)
         : c(), comp(__comp) {}
     _LIBCPP_INLINE_VISIBILITY
     priority_queue(const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     priority_queue(const value_compare& __comp, container_type&& __c);
 #endif
-    template <class _InputIter>
+    template <class _InputIter, class = _EnableIf<__is_cpp17_input_iterator<_InputIter>::value> >
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp = value_compare());
-    template <class _InputIter>
+    template <class _InputIter, class = _EnableIf<__is_cpp17_input_iterator<_InputIter>::value> >
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _InputIter>
+    template <class _InputIter, class = _EnableIf<__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
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit priority_queue(const _Alloc& __a,
                        _EnableIf<uses_allocator<container_type, _Alloc>::value>* = 0);
: c(_VSTD::move(__c)),
       comp(__comp)
 {
     _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-template <class _InputIter>
+template <class _InputIter, class>
 inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp)
     : c(__f, __l),
       comp(__comp)
 {
     _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
-template <class _InputIter>
+template <class _InputIter, class>
 inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           const container_type& __c)
     : c(__c),
       comp(__comp)
 {
     c.insert(c.end(), __f, __l);
     _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-template <class _InputIter>
+template <class _InputIter, class>
 inline
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           container_type&& __c)
     : c(_VSTD::move(__c)),
       comp(__comp)
 {
     c.insert(c.end(), __f, __l);

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <queue>
+
+// template <class InputIterator>
+//   priority_queue(InputIterator first, InputIterator last, const Compare& comp);
+
+#include <queue>
+#include <type_traits>
+#include <vector>
+
+static_assert( std::is_constructible<std::vector<int>, int, int>::value, "");
+static_assert(!std::is_constructible<std::priority_queue<int>, int, int>::value, "");