<utility>: Remove self swap check from pair. (#4674)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>

stl/inc/utility

@@ -441,21 +441,17 @@ struct pair { // store a pair of values
  _CONSTEXPR20 void swap(pair& _Right) noexcept(
  _Is_nothrow_swappable<_Ty1>::value && _Is_nothrow_swappable<_Ty2>::value) {
  using _STD swap;
- if (this != _STD addressof(_Right)) {
- swap(first, _Right.first); // intentional ADL
- swap(second, _Right.second); // intentional ADL
- }
+ swap(first, _Right.first); // intentional ADL
+ swap(second, _Right.second); // intentional ADL
  }
 
 #if _HAS_CXX23
  template <int = 0> // see GH-3013
  constexpr void swap(const pair& _Right) const
  noexcept(is_nothrow_swappable_v<const _Ty1> && is_nothrow_swappable_v<const _Ty2>) {
  using _STD swap;
- if (this != _STD addressof(_Right)) {
- swap(first, _Right.first); // intentional ADL
- swap(second, _Right.second); // intentional ADL
- }
+ swap(first, _Right.first); // intentional ADL
+ swap(second, _Right.second); // intentional ADL
  }
 #endif // _HAS_CXX23
 

tests/std/test.lst

@@ -243,6 +243,7 @@ tests\GH_004201_chrono_formatter
 tests\GH_004275_seeking_fancy_iterators
 tests\GH_004388_unordered_meow_operator_equal
 tests\GH_004477_mdspan_warning_5246
+tests\GH_004597_self_swap
 tests\GH_004618_mixed_operator_usage_keeps_statistical_properties
 tests\GH_004618_normal_distribution_avoids_resets
 tests\GH_004657_expected_constraints_permissive

tests/std/tests/GH_004597_self_swap/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_matrix.lst

tests/std/tests/GH_004597_self_swap/test.cpp

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <utility>
+
+struct swap_counter {
+ unsigned int* pcnt_ = nullptr;
+
+ friend _CONSTEXPR20 void swap(swap_counter& lhs, swap_counter& rhs) noexcept {
+ assert(lhs.pcnt_ != nullptr);
+ assert(rhs.pcnt_ != nullptr);
+ std::swap(lhs.pcnt_, rhs.pcnt_);
+ ++*lhs.pcnt_;
+ ++*rhs.pcnt_;
+ }
+
+ _CONSTEXPR20 bool operator==(unsigned int x) const {
+ assert(pcnt_ != nullptr);
+ return *pcnt_ == x;
+ }
+};
+
+
+// Test GH-4597 "<utility>: Side effects in self-swaps of pair are skipped"
+_CONSTEXPR20 bool test_gh_4597() {
+ {
+ unsigned int cnt{};
+ std::pair<swap_counter, int> pr{swap_counter{&cnt}, 10};
+ pr.swap(pr);
+ assert(cnt == 2u);
+ assert(pr.first == 2u);
+ assert(pr.second == 10);
+ }
+
+ {
+ unsigned int cnt{};
+ std::pair<swap_counter, int> p1{swap_counter{&cnt}, 10};
+ std::pair<swap_counter, int> p2{swap_counter{&cnt}, 11};
+ p1.swap(p2);
+ assert(cnt == 2u);
+ assert(p1.first == 2u);
+ assert(p1.second == 11);
+ assert(p2.first == 2u);
+ assert(p2.second == 10);
+ }
+
+ {
+ unsigned int c1{};
+ unsigned int c2{2};
+ std::pair<swap_counter, int> p1{swap_counter{&c1}, 11};
+ std::pair<swap_counter, int> p2{swap_counter{&c2}, 13};
+ p1.swap(p2);
+ assert(c1 == 1u);
+ assert(c2 == 3u);
+ assert(p1.first == 3u);
+ assert(p1.second == 13);
+ assert(p2.first == 1u);
+ assert(p2.second == 11);
+ }
+
+#if _HAS_CXX23
+ {
+ unsigned int c1{};
+ unsigned int c2{2};
+ int i1 = 11;
+ int i2 = 13;
+ swap_counter s1{&c1};
+ swap_counter s2{&c2};
+ const std::pair<swap_counter&, int&> p1{s1, i1};
+ const std::pair<swap_counter&, int&> p2{s2, i2};
+ p1.swap(p2);
+ assert(c1 == 1u);
+ assert(c2 == 3u);
+ assert(p1.first == 3u);
+ assert(p1.second == 13);
+ assert(p2.first == 1u);
+ assert(p2.second == 11);
+ }
+#endif // _HAS_CXX23
+
+ return true;
+}
+
+int main() {
+#if _HAS_CXX20
+ static_assert(test_gh_4597());
+#endif // _HAS_CXX20
+ assert(test_gh_4597());
+}