[llvm-branch-commits] [llvm] f1278ce - Revert "[ADT] Allow SmallVector move construction without move assignment (#2…"

[via llvm-branch-commits]

Author: Mehdi Amini
Date: 2026-09-02T11:54:48+02:00
New Revision: f1278ce113a89e8476f216a358002deb8efe94a7

URL: https://github.com/llvm/llvm-project/commit/f1278ce113a89e8476f216a358002deb8efe94a7
DIFF: https://github.com/llvm/llvm-project/commit/f1278ce113a89e8476f216a358002deb8efe94a7.diff

LOG: Revert "[ADT] Allow SmallVector move construction without move assignment (#2…"

This reverts commit af2ddf42e4499169f8d96d1ff928f3d92bbcc9a2.

Added: 
    

Modified: 
    llvm/include/llvm/ADT/SmallVector.h
    llvm/unittests/ADT/SmallVectorTest.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/ADT/SmallVector.h b/llvm/include/llvm/ADT/SmallVector.h
index d7fcc3a97a88c..134c74bfd48d0 100644
--- a/llvm/include/llvm/ADT/SmallVector.h
+++ b/llvm/include/llvm/ADT/SmallVector.h
@@ -616,20 +616,6 @@ class SmallVectorImpl : public SmallVectorTemplateBase<T> {
     RHS.resetToSmall();
   }
 
-  void moveConstructFrom(SmallVectorImpl &&RHS) {
-    assert(this->empty() && "move construction requires an empty vector");
-    if (!RHS.isSmall()) {
-      assignRemote(std::move(RHS));
-      return;
-    }
-
-    // Construct inline elements directly instead of requiring T to be move
-    // assignable through the general move-assignment implementation.
-    append(std::make_move_iterator(RHS.begin()),
-           std::make_move_iterator(RHS.end()));
-    RHS.clear();
-  }
-
   ~SmallVectorImpl() {
     // Subclass has already destructed this vector's elements.
     // If this wasn't grown from the inline copy, deallocate the old space.
@@ -1297,12 +1283,12 @@ class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
 
   SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
     if (!RHS.empty())
-      this->moveConstructFrom(::std::move(RHS));
+      SmallVectorImpl<T>::operator=(::std::move(RHS));
   }
 
   SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
     if (!RHS.empty())
-      this->moveConstructFrom(::std::move(RHS));
+      SmallVectorImpl<T>::operator=(::std::move(RHS));
   }
 
   SmallVector &operator=(SmallVector &&RHS) {

diff  --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp
index 03f58fabeb54c..4a32c6d2ff08a 100644
--- a/llvm/unittests/ADT/SmallVectorTest.cpp
+++ b/llvm/unittests/ADT/SmallVectorTest.cpp
@@ -167,22 +167,6 @@ struct NonCopyable {
   NonCopyable &operator=(const NonCopyable &) = delete;
 };
 
-struct MoveConstructOnly {
-  explicit MoveConstructOnly(int Value) : Value(Value) {}
-  MoveConstructOnly(MoveConstructOnly &&RHS) : Value(RHS.Value) {
-    RHS.Value = -1;
-  }
-
-  MoveConstructOnly(const MoveConstructOnly &) = delete;
-  MoveConstructOnly &operator=(const MoveConstructOnly &) = delete;
-  MoveConstructOnly &operator=(MoveConstructOnly &&) = delete;
-
-  int Value;
-};
-
-static_assert(std::is_move_constructible_v<MoveConstructOnly>);
-static_assert(!std::is_move_assignable_v<MoveConstructOnly>);
-
 LLVM_ATTRIBUTE_USED void CompileTest() {
   SmallVector<NonCopyable, 0> V;
   V.resize(42);
@@ -193,50 +177,6 @@ TEST(SmallVectorTest, ConstructNonCopyableTest) {
   EXPECT_EQ(V.size(), (size_t)42);
 }
 
-TEST(SmallVectorTest, MoveConstructNonMoveAssignableInlineElements) {
-  SmallVector<MoveConstructOnly, 2> From;
-  From.emplace_back(1);
-  From.emplace_back(2);
-  const MoveConstructOnly *FromData = From.data();
-
-  SmallVector<MoveConstructOnly, 2> To(std::move(From));
-
-  EXPECT_TRUE(From.empty());
-  ASSERT_EQ(2u, To.size());
-  EXPECT_NE(FromData, To.data());
-  EXPECT_EQ(1, To[0].Value);
-  EXPECT_EQ(2, To[1].Value);
-}
-
-TEST(SmallVectorTest, MoveConstructNonMoveAssignableAllocatedElements) {
-  SmallVector<MoveConstructOnly, 1> From;
-  From.emplace_back(1);
-  From.emplace_back(2);
-  const MoveConstructOnly *FromData = From.data();
-
-  SmallVector<MoveConstructOnly, 1> To(std::move(From));
-
-  EXPECT_TRUE(From.empty());
-  ASSERT_EQ(2u, To.size());
-  EXPECT_EQ(FromData, To.data());
-  EXPECT_EQ(1, To[0].Value);
-  EXPECT_EQ(2, To[1].Value);
-}
-
-TEST(SmallVectorTest, MoveConstructNonMoveAssignableFromSmallVectorImpl) {
-  SmallVector<MoveConstructOnly, 2> From;
-  From.emplace_back(1);
-  From.emplace_back(2);
-
-  SmallVector<MoveConstructOnly, 0> To(
-      std::move(static_cast<SmallVectorImpl<MoveConstructOnly> &>(From)));
-
-  EXPECT_TRUE(From.empty());
-  ASSERT_EQ(2u, To.size());
-  EXPECT_EQ(1, To[0].Value);
-  EXPECT_EQ(2, To[1].Value);
-}
-
 // Assert that v contains the specified values, in order.
 template <typename VectorT>
 void assertValuesInOrder(VectorT &v, size_t size, ...) {