OPTIONAL: Remove the requirement of replaceability

This is an optional relaxation in case we are OK with changing
the behavior for some users that had questionable assignment
operators.

Author: ldionne

libcxx/include/__vector/vector.h

@@ -502,12 +502,7 @@ class _LIBCPP_TEMPLATE_VIS vector {
         // Otherwise, we have no choice but to shift everything to the right using move-assignments
         // and to move-assign the new element into its final location, to ensure that everything gets
         // properly destroyed in case of an exception.
-        //
-        // Note that we also require __is_replaceable here for backwards compatibility, because we used
-        // to perform move-assignments unconditionally. If we didn't enforce that, we would no longer call
-        // the assignment operator of types that have a funky operator= and expect it to be called in
-        // vector::insert.
-        if constexpr (__is_replaceable<value_type>::value && is_nothrow_constructible<value_type>::value) {
+        if constexpr (is_nothrow_constructible<value_type>::value) {
           // Relocate all the elements in the vector to open up a gap.
           std::__uninitialized_allocator_relocate(this->__alloc_, __position, end(), __position + 1);
 
@@ -601,12 +596,7 @@ class _LIBCPP_TEMPLATE_VIS vector {
     // If the value_type is nothrow move constructible, we destroy the range being erased and we
     // relocate the tail of the vector into the created gap. This is especially efficient if the
     // elements are trivially relocatable. Otherwise, we use the standard technique with move-assignments.
-    //
-    // Note that we also require __is_replaceable here for backwards compatibility, because we used
-    // to perform move-assignments unconditionally. If we didn't enforce that, we would no longer call
-    // the assignment operator of types that have a funky operator= and expect it to be called in
-    // vector::erase.
-    if constexpr (__is_replaceable<value_type>::value && is_nothrow_move_constructible<value_type>::value) {
+    if constexpr (is_nothrow_move_constructible<value_type>::value) {
       std::__allocator_destroy(this->__alloc_, __first, __last);
       std::__uninitialized_allocator_relocate(this->__alloc_, __last, end(), __first);
     } else {

libcxx/test/std/containers/sequences/vector/vector.modifiers/common.h

@@ -40,28 +40,6 @@ struct Throws {
 bool Throws::sThrows = false;
 #endif
 
-struct Tracker {
-  int copy_assignments = 0;
-  int move_assignments = 0;
-};
-
-struct TrackedAssignment {
-  Tracker* tracker_;
-  TEST_CONSTEXPR_CXX14 explicit TrackedAssignment(Tracker* tracker) : tracker_(tracker) {}
-
-  TrackedAssignment(TrackedAssignment const&) = default;
-  TrackedAssignment(TrackedAssignment&&)      = default;
-
-  TEST_CONSTEXPR_CXX14 TrackedAssignment& operator=(TrackedAssignment const&) {
-    tracker_->copy_assignments++;
-    return *this;
-  }
-  TEST_CONSTEXPR_CXX14 TrackedAssignment& operator=(TrackedAssignment&&) {
-    tracker_->move_assignments++;
-    return *this;
-  }
-};
-
 struct NonTriviallyRelocatable {
   int value_;
   TEST_CONSTEXPR NonTriviallyRelocatable() : value_(0) {}

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp

@@ -107,31 +107,5 @@ int main(int, char**) {
   }
 #endif
 
-  // Make sure we satisfy the complexity requirement in terms of the number of times the assignment
-  // operator is called.
-  //
-  // There is currently ambiguity as to whether this is truly mandated by the Standard, so we only
-  // test it for libc++.
-#ifdef _LIBCPP_VERSION
-  {
-    Tracker tracker;
-    std::vector<TrackedAssignment> v;
-
-    // Set up the vector with 5 elements.
-    for (int i = 0; i != 5; ++i) {
-      v.emplace_back(&tracker);
-    }
-    assert(tracker.copy_assignments == 0);
-    assert(tracker.move_assignments == 0);
-
-    // Erase element [1] from it. Elements [2] [3] [4] should be shifted, so we should
-    // see 3 move assignments (and nothing else).
-    v.erase(v.begin() + 1);
-    assert(v.size() == 4);
-    assert(tracker.copy_assignments == 0);
-    assert(tracker.move_assignments == 3);
-  }
-#endif
-
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp

@@ -196,31 +196,5 @@ int main(int, char**) {
     assert(it == v.begin() + 2);
   }
 
-  // Make sure we satisfy the complexity requirement in terms of the number of times the assignment
-  // operator is called.
-  //
-  // There is currently ambiguity as to whether this is truly mandated by the Standard, so we only
-  // test it for libc++.
-#ifdef _LIBCPP_VERSION
-  {
-    Tracker tracker;
-    std::vector<TrackedAssignment> v;
-
-    // Set up the vector with 5 elements.
-    for (int i = 0; i != 5; ++i) {
-      v.emplace_back(&tracker);
-    }
-    assert(tracker.copy_assignments == 0);
-    assert(tracker.move_assignments == 0);
-
-    // Erase elements [1] and [2] from it. Elements [3] [4] should be shifted, so we should
-    // see 2 move assignments (and nothing else).
-    v.erase(v.begin() + 1, v.begin() + 3);
-    assert(v.size() == 3);
-    assert(tracker.copy_assignments == 0);
-    assert(tracker.move_assignments == 2);
-  }
-#endif
-
   return 0;
 }