inlined_vector: Use trivial relocation for erase

Trivial relocatability also requires that the type not do anything
weird with its assignment operator; update the type-trait to reflect
this. (This is the definition used by BSL, Folly, HPX, Thrust,
Parlay, Amadeus, and P1144.)

Clang's builtin currently fails to check the assignment operator,
but Abseil's type trait already refuses to use Clang's builtin.
I'm working on getting that fixed in Clang.

The reason this is important is that we want to be able to use memcpy
to speedily relocate elements also in vector::erase. Implement that
optimization for `absl::inlined_vector`.

Prior art for the `vector::erase` optimization:
https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L3787-L3799
https://github.com/facebook/folly/blob/main/folly/FBVector.h#L1254
https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L856-L861

Author: Quuxplusone

absl/container/internal/inlined_vector.h

@@ -894,16 +894,30 @@ auto Storage<T, N, A>::Erase(ConstIterator<A> from, ConstIterator<A> to)
       std::distance(ConstIterator<A>(storage_view.data), from));
   SizeType<A> erase_end_index = erase_index + erase_size;
 
-  IteratorValueAdapter<A, MoveIterator<A>> move_values(
-      MoveIterator<A>(storage_view.data + erase_end_index));
-
-  AssignElements<A>(storage_view.data + erase_index, move_values,
-                    storage_view.size - erase_end_index);
+  // Fast path: if the value type is trivially relocatable and we know
+  // the allocator doesn't do anything fancy, then we know it is legal for us to
+  // simply destroy the elements in the "erasure window" (which cannot throw)
+  // and then memcpy downward to close the window.
+  if (absl::is_trivially_relocatable<value_type>::value &&
+      std::is_nothrow_destructible<value_type>::value &&
+      std::is_same<A, std::allocator<T>>::value) {
+    DestroyAdapter<A>::DestroyElements(
+        GetAllocator(), storage_view.data + erase_index,
+        erase_size);
+    std::memmove(reinterpret_cast<char*>(storage_view.data + erase_index),
+                 reinterpret_cast<const char*>(storage_view.data + erase_end_index),
+                 storage_view.size - erase_end_index);
+  } else {
+    IteratorValueAdapter<A, MoveIterator<A>> move_values(
+        MoveIterator<A>(storage_view.data + erase_end_index));
 
-  DestroyAdapter<A>::DestroyElements(
-      GetAllocator(), storage_view.data + (storage_view.size - erase_size),
-      erase_size);
+    AssignElements<A>(storage_view.data + erase_index, move_values,
+                      storage_view.size - erase_end_index);
 
+    DestroyAdapter<A>::DestroyElements(
+        GetAllocator(), storage_view.data + (storage_view.size - erase_size),
+        erase_size);
+  }
   SubtractSize(erase_size);
   return Iterator<A>(storage_view.data + erase_index);
 }

absl/meta/type_traits.h

@@ -519,12 +519,11 @@ struct is_trivially_relocatable
     : std::integral_constant<bool, __is_trivially_relocatable(T)> {};
 #else
 // Otherwise we use a fallback that detects only those types we can feasibly
-// detect. Any time that has trivial move-construction and destruction
-// operations is by definition trivially relocatable.
+// detect. Any type that is trivially copyable is by definition trivially
+// relocatable.
 template <class T>
 struct is_trivially_relocatable
-    : absl::conjunction<absl::is_trivially_move_constructible<T>,
-                        absl::is_trivially_destructible<T>> {};
+    : absl::is_trivially_copyable<T> {};
 #endif
 
 // absl::is_constant_evaluated()