[WIP][libc++] forward_list allow rvalues in C++03.

[Mordante]

Summary

Based on remarks by Quuxplusone during the review of D113364.

Tested locally this works, but I want a CI run before looking at the
other rvalues disabled in C++03.

[• Quuxplusone]

FWIW, I would expect this to pass CI, and I think it's a good idea (but only if the matching change is made to std::list).

I did some stuff earlier this year (or last year?) to extend our C++11 support back into C++03-plus-Clang-extensions, but then kinda lost momentum after the first or second PR because it turned out that there were a lot of awkward non-technical decision points. Like, I thought it would make sense to enable c.emplace{,_front,_back} in C++03 mode, but not to enable c's own move-constructors and move-assignment-operators; which left c.insert(value_type&&) in a gray area in the middle (and leaning toward not). Which means the patches weren't the nice "rip out a bunch of ifdefs" you'd probably expect; instead they turned into "fiddle with the placement of the ifdefs," which was much less satisfying.

Anyway, I can't think of any reason anyone would object to enabling list::merge-for-rvalues in C++03 mode.

[Mordante]

Let's not backport more features to C++03.

libcxx/include/forward_list

#endif
     void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
     void splice_after(const_iterator __p, forward_list& __x,
                       const_iterator __f, const_iterator __l);
     __remove_return_type remove(const value_type& __v);
     template <class _Predicate> __remove_return_type remove_if(_Predicate __pred);
     _LIBCPP_INLINE_VISIBILITY
     __remove_return_type unique() {return unique(__equal_to<value_type>());}
     template <class _BinaryPredicate> __remove_return_type unique(_BinaryPredicate __binary_pred);
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
     template <class _Compare>
-        _LIBCPP_INLINE_VISIBILITY
-        void merge(forward_list&& __x, _Compare __comp)
-        {merge(__x, _VSTD::move(__comp));}
-#endif // _LIBCPP_CXX03_LANG
+    void merge(forward_list&& __x, _Compare __comp) {merge(__x, _VSTD::move(__comp));}
     _LIBCPP_INLINE_VISIBILITY
     void merge(forward_list& __x) {merge(__x, __less<value_type>());}
     template <class _Compare> void merge(forward_list& __x, _Compare __comp);
     _LIBCPP_INLINE_VISIBILITY
     void sort() {sort(__less<value_type>());}
     template <class _Compare> _LIBCPP_INLINE_VISIBILITY void sort(_Compare __comp);
     void reverse() _NOEXCEPT;
 

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_rvalue.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
-
 // <forward_list>
 
 // void merge(forward_list&& x);
 
 #include <forward_list>
 #include <functional>
 #include <iterator>
 #include <vector>
int main(int, char**) {
     c1.merge(std::move(c2));
     assert(c2.empty());
 
     C c3(std::begin(t3), std::end(t3));
     assert(c1 == c3);
   }
   { // Test with a different allocator.
     typedef int T;
-    typedef std::forward_list<T, min_allocator<T>> C;
+    typedef std::forward_list<T, min_allocator<T> > C;
     const T t1[] = {3, 5, 6, 7, 12, 13};
     const T t2[] = {0, 1, 2, 4, 8, 9, 10, 11, 14, 15};
     const T t3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
 
     C c1(std::begin(t1), std::end(t1));
     C c2(std::begin(t2), std::end(t2));
     c1.merge(std::move(c2));
     assert(c2.empty());
 
     C c3(std::begin(t3), std::end(t3));
     assert(c1 == c3);
   }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/merge_rvalue_pred.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
-
 // <forward_list>
 
 // template <class Compare> void merge(forward_list&& x, Compare comp);
 
 #include <forward_list>
 #include <functional>
 #include <iterator>
 #include <vector>
int main(int, char**) {
     assert(c2.empty());
 
     C c3(std::begin(t3), std::end(t3));
     assert(c1 == c3);
   }
 
   { // Test with a different allocator.
     typedef int T;
-    typedef std::forward_list<T, min_allocator<T>> C;
+    typedef std::forward_list<T, min_allocator<T> > C;
     const T t1[] = {13, 12, 7, 6, 5, 3};
     const T t2[] = {15, 14, 11, 10, 9, 8, 4, 2, 1, 0};
     const T t3[] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
 
     C c1(std::begin(t1), std::end(t1));
     C c2(std::begin(t2), std::end(t2));
     c1.merge(std::move(c2), std::greater<T>());
     assert(c2.empty());
 
     C c3(std::begin(t3), std::end(t3));
     assert(c1 == c3);
   }
 
   return 0;
 }