Cherry-picks for LTS 20260107 (#1990)

* Fix unused variable warning in GCC7

PiperOrigin-RevId: 853321697
Change-Id: I44b09e10e6ca1bb9b9f30a01a0f5acd5923371c1

* Fix self-move handling in absl::linked_hash_{set|map}

PiperOrigin-RevId: 853340964
Change-Id: I818695f01d53b5515be24122e1988e69ad6421d4

Author: derekmauro

absl/container/linked_hash_map.h

@@ -248,22 +248,25 @@ class linked_hash_map {
   }
 
   linked_hash_map& operator=(const linked_hash_map& other) {
-    if (this == &other) return *this;
-    // Make a new set, with other's hash/eq/alloc.
-    set_ = SetType(other.bucket_count(), other.set_.hash_function(),
-                   other.set_.key_eq(), other.get_allocator());
-    // Copy the list, with other's allocator.
-    list_ = ListType(other.get_allocator());
-    CopyFrom(other);
+    if (this != &other) {
+      // Make a new set, with other's hash/eq/alloc.
+      set_ = SetType(other.bucket_count(), other.set_.hash_function(),
+                     other.set_.key_eq(), other.get_allocator());
+      // Copy the list, with other's allocator.
+      list_ = ListType(other.get_allocator());
+      CopyFrom(other);
+    }
     return *this;
   }
 
   linked_hash_map& operator=(linked_hash_map&& other) noexcept {
-    // underlying containers will handle progagate_on_container_move details
-    set_ = std::move(other.set_);
-    list_ = std::move(other.list_);
-    other.set_.clear();
-    other.list_.clear();
+    if (this != &other) {
+      // underlying containers will handle progagate_on_container_move details
+      set_ = std::move(other.set_);
+      list_ = std::move(other.list_);
+      other.set_.clear();
+      other.list_.clear();
+    }
     return *this;
   }
 

absl/container/linked_hash_map_test.cc

@@ -98,6 +98,14 @@ TEST(LinkedHashMapTest, Assign) {
   FAIL() << "Assigned map's find method returned an invalid iterator.";
 }
 
+// Tests that self-assignment works.
+TEST(LinkedHashMapTest, SelfAssign) {
+  linked_hash_map<int, int> a{{1, 1}, {2, 2}, {3, 3}};
+  auto& a_ref = a;
+  a = a_ref;
+  EXPECT_THAT(a, ElementsAre(Pair(1, 1), Pair(2, 2), Pair(3, 3)));
+}
+
 // Tests that move constructor works.
 TEST(LinkedHashMapTest, Move) {
   // Use unique_ptr as an example of a non-copyable type.
@@ -108,6 +116,14 @@ TEST(LinkedHashMapTest, Move) {
   EXPECT_THAT(n, ElementsAre(Pair(2, Pointee(12)), Pair(3, Pointee(13))));
 }
 
+// Tests that self-moving works.
+TEST(LinkedHashMapTest, SelfMove) {
+  linked_hash_map<int, int> a{{1, 1}, {2, 2}, {3, 3}};
+  auto& a_ref = a;
+  a = std::move(a_ref);
+  EXPECT_THAT(a, ElementsAre(Pair(1, 1), Pair(2, 2), Pair(3, 3)));
+}
+
 TEST(LinkedHashMapTest, CanInsertMoveOnly) {
   linked_hash_map<int, std::unique_ptr<int>> m;
   struct Data {
@@ -512,6 +528,13 @@ TEST(LinkedHashMapTest, Swap) {
   ASSERT_EQ(2, m2.size());
 }
 
+TEST(LinkedHashMapTest, SelfSwap) {
+  linked_hash_map<int, int> a{{1, 1}, {2, 2}, {3, 3}};
+  using std::swap;
+  swap(a, a);
+  EXPECT_THAT(a, ElementsAre(Pair(1, 1), Pair(2, 2), Pair(3, 3)));
+}
+
 TEST(LinkedHashMapTest, InitializerList) {
   linked_hash_map<int, int> m{{1, 2}, {3, 4}};
   ASSERT_EQ(2, m.size());

absl/container/linked_hash_set.h

@@ -238,21 +238,24 @@ class linked_hash_set {
   }
 
   linked_hash_set& operator=(const linked_hash_set& other) {
-    if (this == &other) return *this;
-    // Make a new set, with other's hash/eq/alloc.
-    set_ = SetType(other.bucket_count(), other.set_.hash_function(),
-                   other.set_.key_eq(), other.get_allocator());
-    // Copy the list, with other's allocator.
-    list_ = ListType(other.get_allocator());
-    CopyFrom(other);
+    if (this != &other) {
+      // Make a new set, with other's hash/eq/alloc.
+      set_ = SetType(other.bucket_count(), other.set_.hash_function(),
+                     other.set_.key_eq(), other.get_allocator());
+      // Copy the list, with other's allocator.
+      list_ = ListType(other.get_allocator());
+      CopyFrom(other);
+    }
     return *this;
   }
 
   linked_hash_set& operator=(linked_hash_set&& other) noexcept {
-    set_ = std::move(other.set_);
-    list_ = std::move(other.list_);
-    other.set_.clear();
-    other.list_.clear();
+    if (this != &other) {
+      set_ = std::move(other.set_);
+      list_ = std::move(other.list_);
+      other.set_.clear();
+      other.list_.clear();
+    }
     return *this;
   }
 

absl/container/linked_hash_set_test.cc

@@ -91,6 +91,21 @@ TEST(LinkedHashSetTest, Assign) {
   FAIL() << "Assigned set's find method returned an invalid iterator.";
 }
 
+// Tests that self-assignment works.
+TEST(LinkedHashSetTest, SelfAssign) {
+  linked_hash_set<int> a{1, 2, 3};
+  auto& a_ref = a;
+  a = a_ref;
+
+  EXPECT_TRUE(a.contains(2));
+  auto found = a.find(2);
+  ASSERT_TRUE(found != a.end());
+  for (auto iter = a.begin(); iter != a.end(); ++iter) {
+    if (iter == found) return;
+  }
+  FAIL() << "Assigned set's find method returned an invalid iterator.";
+}
+
 // Tests that move constructor works.
 TEST(LinkedHashSetTest, Move) {
   // Use unique_ptr as an example of a non-copyable type.
@@ -101,6 +116,14 @@ TEST(LinkedHashSetTest, Move) {
   EXPECT_THAT(n, ElementsAre(Pointee(2), Pointee(3)));
 }
 
+// Tests that self-moving works.
+TEST(LinkedHashSetTest, SelfMove) {
+  linked_hash_set<int> a{1, 2, 3};
+  auto& a_ref = a;
+  a = std::move(a_ref);
+  EXPECT_THAT(a, ElementsAre(1, 2, 3));
+}
+
 struct IntUniquePtrHash {
   size_t operator()(const std::unique_ptr<int>& p) const {
     return static_cast<size_t>(*p);
@@ -521,6 +544,13 @@ TEST(LinkedHashSetTest, Swap) {
   ASSERT_EQ(2, m2.size());
 }
 
+TEST(LinkedHashSetTest, SelfSwap) {
+  linked_hash_set<int> a{1, 2, 3};
+  using std::swap;
+  swap(a, a);
+  EXPECT_THAT(a, ElementsAre(1, 2, 3));
+}
+
 TEST(LinkedHashSetTest, InitializerList) {
   linked_hash_set<int> m{1, 3};
   ASSERT_EQ(2, m.size());

absl/strings/internal/str_format/float_conversion.cc

@@ -1745,7 +1745,7 @@ void FormatEPositiveExpSlow(uint128 mantissa, int exp, bool uppercase,
         bool change_to_zeros = false;
         if (nines + 1 >= digits_to_go) {
           // Everything we need to print is in the first DigitRun
-          auto [next_digit_opt, next_nines] = GetDigits(btd, digits_view);
+          auto next_digit_opt = GetDigits(btd, digits_view).digit;
           if (nines == state.precision) {
             change_to_zeros = next_digit_opt.value_or(0) > 4;
           } else {
@@ -1793,7 +1793,7 @@ void FormatEPositiveExpSlow(uint128 mantissa, int exp, bool uppercase,
             digits_to_go -= curr_nines + 1;
           } else {
             bool need_round_up = false;
-            auto [next_digit_opt, next_nines] = GetDigits(btd, digits_view);
+            auto next_digit_opt = GetDigits(btd, digits_view).digit;
             if (digits_to_go == 1) {
               need_round_up = curr_nines > 0 || next_digit_opt > 4;
             } else if (digits_to_go == curr_nines + 1) {