[libc++] Implement LWG-3204 sub_match::swap only swaps the base class

[fsb4000]

Summary

https://cplusplus.github.io/LWG/issue3204

[JMazurkiewicz]

libcxx/test/std/re/re.submatch/re.submatch.members/swap.pass.cpp

21

Both uses of this macro test if operation is noexcept - we can replace it with ASSERT_NOEXCEPT macro (https://github.com/llvm/llvm-project/blob/6c82d16d6092302c0d90ccb672a6ceba0b4a84d2/libcxx/test/support/test_macros.h#L219-L228).

46

70

[fsb4000]

Thank you Jakub Mazurkiewicz!

[fsb4000]

_NOEXCEPT instead of noexcept for C++03 support

[Mordante]

Thanks for your patch. In general LGTM, but I would like to have a look at the changes to the test.

libcxx/include/regex

5015

This is the preferred way. (At some point we probably should update the existing code base.)

5018

The indention looks off.

libcxx/test/std/re/re.submatch/re.submatch.members/swap.pass.cpp

26

This looks slightly confusion, I expect first and second to point to the same range.
Can you use the ideas used in libcxx/test/std/re/re.submatch/re.submatch.members/length.pass.cpp ?

[Mordante]

LGTM modulo some nits.

libcxx/test/std/re/re.submatch/re.submatch.members/swap.pass.cpp

22–23

This is our new style preference, the same for wchar_t.

27

please use clang-format for this new file.

[fsb4000]

libcxx/test/std/re/re.submatch/re.submatch.members/swap.pass.cpp

27

Is clang-format-15 ok?

I see that clang-format-16 is used but I only have clang-format-15.

[Mordante]

libcxx/test/std/re/re.submatch/re.submatch.members/swap.pass.cpp

27

Yes that's fine. They should behave the same for this file. We use a newer version for better formatting of C++20 features like concepts.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3664 <https://wg21.link/LWG3664>`__","`LWG 3392 <https://wg21.link/LWG3392>`__ ``broke std::ranges::distance(a, a+3)``","February 2023","","","|ranges|"
 "`3720 <https://wg21.link/LWG3720>`__","Restrict the valid types of ``arg-id`` for width and precision in ``std-format-spec``","February 2023","","","|format|"
 "`3756 <https://wg21.link/LWG3756>`__","Is the ``std::atomic_flag`` class signal-safe?","February 2023","","",""
 "`3769 <https://wg21.link/LWG3769>`__","``basic_const_iterator::operator==`` causes infinite constraint recursion","February 2023","","","|spaceship|"
 "`3807 <https://wg21.link/LWG3807>`__","The feature test macro for ``ranges::find_last`` should be renamed","February 2023","","","|ranges|"
 "`3811 <https://wg21.link/LWG3811>`__","``views::as_const`` on ``ref_view<T>`` should return ``ref_view<const T>``","February 2023","","","|ranges|"
 "`3820 <https://wg21.link/LWG3820>`__","``cartesian_product_view::iterator::prev`` is not quite right","February 2023","","","|ranges|"
 "`3825 <https://wg21.link/LWG3825>`__","Missing compile-time argument ``id`` check in ``basic_format_parse_context::next_arg_id``","February 2023","","","|format|"
-"`3204 <https://wg21.link/LWG3204>`__","``sub_match::swap`` only swaps the base class","February 2023","","",""
+"`3204 <https://wg21.link/LWG3204>`__","``sub_match::swap`` only swaps the base class","February 2023","|Complete|","17.0",""
 "`3733 <https://wg21.link/LWG3733>`__","``ranges::to`` misuses ``cpp17-input-iterator``","February 2023","","","|ranges|"
 "`3742 <https://wg21.link/LWG3742>`__","``deque::prepend_range`` needs to permute","February 2023","","","|ranges|"
 "`3790 <https://wg21.link/LWG3790>`__","`P1467 <https://wg21.link/P1467>`__ accidentally changed ``nexttoward``'s signature","February 2023","","",""
 "`3819 <https://wg21.link/LWG3819>`__","``reference_meows_from_temporary`` should not use ``is_meowible``","February 2023","","",""
 "`3821 <https://wg21.link/LWG3821>`__","``uses_allocator_construction_args`` should have overload for ``pair-like``","February 2023","","",""
 "`3834 <https://wg21.link/LWG3834>`__","Missing ``constexpr`` for ``std::intmax_t`` math functions in ``<cinttypes>``","February 2023","","",""
 "`3839 <https://wg21.link/LWG3839>`__","``range_formatter``'s ``set_separator``, ``set_brackets``, and ``underlying`` functions should be ``noexcept``","February 2023","","","|format|"
 "`3841 <https://wg21.link/LWG3841>`__","``<version>`` should not be ""all freestanding""","February 2023","","",""

libcxx/include/regex

public:
 
     difference_type length() const;
     operator string_type() const;
     string_type str() const;
 
     int compare(const sub_match& s) const;
     int compare(const string_type& s) const;
     int compare(const value_type* s) const;
+
+    void swap(sub_match& s) noexcept(see below);
 };
 
 typedef sub_match<const char*>             csub_match;
 typedef sub_match<const wchar_t*>          wcsub_match;
 typedef sub_match<string::const_iterator>  ssub_match;
 typedef sub_match<wstring::const_iterator> wssub_match;
 
 template <class BiIter>

 #include <__algorithm/find.h>
 #include <__algorithm/search.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__type_traits/is_swappable.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <deque>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
public:
     int compare(const sub_match& __s) const
         {return str().compare(__s.str());}
     _LIBCPP_INLINE_VISIBILITY
     int compare(const string_type& __s) const
         {return str().compare(__s);}
     _LIBCPP_INLINE_VISIBILITY
     int compare(const value_type* __s) const
         {return str().compare(__s);}
+
+    _LIBCPP_HIDE_FROM_ABI
+    void swap(sub_match& __s)
+#ifndef _LIBCPP_CXX03_LANG
+    _NOEXCEPT(__is_nothrow_swappable<_BidirectionalIterator>::value)
+#endif // _LIBCPP_CXX03_LANG
+    {
+        this->pair<_BidirectionalIterator, _BidirectionalIterator>::swap(__s);
+        std::swap(matched, __s.matched);
+    }
 };
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return __x.compare(__y) == 0;

libcxx/test/std/re/re.submatch/re.submatch.members/swap.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
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+
+// template <class BidirectionalIterator> class sub_match;
+
+// void swap(sub_match& s) noexcept(see below);
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        typedef char CharT;
+        typedef std::sub_match<const CharT*> SM;
+        const CharT s1[] = {'1', '2', '3', 0};
+        SM sm1;
+        sm1.first   = s1;
+        sm1.second  = s1+3;
+        sm1.matched = true;
+
+        SM sm2;
+        const CharT s2[] = {'c', 'a', 't', 0};
+        sm2.first   = s2;
+        sm2.second  = s2+3;
+        sm2.matched = false;
+
+        sm1.swap(sm2);
+
+        assert(sm1.first == s2);
+        assert(sm1.second == s2+3);
+        assert(!sm1.matched);
+
+        assert(sm2.first == s1);
+        assert(sm2.second == s1+3);
+        assert(sm2.matched);
+
+        ASSERT_NOEXCEPT(sm1.swap(sm2));
+    }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    {
+        typedef wchar_t CharT;
+        typedef std::sub_match<const CharT*> SM;
+        const CharT s1[] = {L'1', L'2', L'3', 0};
+        SM sm1;
+        sm1.first   = s1;
+        sm1.second  = s1+3;
+        sm1.matched = true;
+
+        SM sm2;
+        const CharT s2[] = {L'c', L'a', L't', 0};
+        sm2.first   = s2;
+        sm2.second  = s2+3;
+        sm2.matched = false;
+
+        sm1.swap(sm2);
+
+        assert(sm1.first == s2);
+        assert(sm1.second == s2+3);
+        assert(!sm1.matched);
+
+        assert(sm2.first == s1);
+        assert(sm2.second == s1+3);
+        assert(sm2.matched);
+
+        ASSERT_NOEXCEPT(sm1.swap(sm2));
+    }
+#endif
+}