5 files changed, 49 insertions, 49 deletions

diff --git a/llvm/include/llvm/ADT/SmallString.h b/llvm/include/llvm/ADT/SmallString.h
index e569f54481a..740a0a5cd84 100644
--- a/llvm/include/llvm/ADT/SmallString.h
+++ b/llvm/include/llvm/ADT/SmallString.h
@@ -28,30 +28,18 @@ public:
   SmallString() {}
 
   /// Initialize from a StringRef.
-  SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
+  /*implicit*/ SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
 
   /// Initialize with a range.
   template<typename ItTy>
   SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
 
-  // Note that in order to add new overloads for append & assign, we have to
-  // duplicate the inherited versions so as not to inadvertently hide them.
-
   /// @}
   /// @name String Assignment
   /// @{
 
-  /// Assign from a repeated element.
-  void assign(size_t NumElts, char Elt) {
-    this->SmallVectorImpl<char>::assign(NumElts, Elt);
-  }
-
-  /// Assign from an iterator pair.
-  template<typename in_iter>
-  void assign(in_iter S, in_iter E) {
-    this->clear();
-    SmallVectorImpl<char>::append(S, E);
-  }
+  // Provide assign from SmallVectorImpl<char>
+  using SmallVectorImpl<char>::assign;
 
   /// Assign from a StringRef.
   void assign(StringRef RHS) {
@@ -65,20 +53,7 @@ public:
     SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
   }
 
-  /// @}
-  /// @name String Concatenation
-  /// @{
-
-  /// Append from an iterator pair.
-  template<typename in_iter>
-  void append(in_iter S, in_iter E) {
-    SmallVectorImpl<char>::append(S, E);
-  }
-
-  void append(size_t NumInputs, char Elt) {
-    SmallVectorImpl<char>::append(NumInputs, Elt);
-  }
-
+  using SmallVectorImpl<char>::append;
 
   /// Append from a StringRef.
   void append(StringRef RHS) {
@@ -94,12 +69,6 @@ public:
   /// @name String Comparison
   /// @{
 
-  /// Check for string equality.  This is more efficient than compare() when
-  /// the relative ordering of inequal strings isn't needed.
-  bool equals(StringRef RHS) const {
-    return str().equals(RHS);
-  }
-
   /// Check for string equality, ignoring case.
   bool equals_lower(StringRef RHS) const {
     return str().equals_lower(RHS);
@@ -276,6 +245,9 @@ public:
   /// Implicit conversion to StringRef.
   operator StringRef() const { return str(); }
 
+  // Provide op= for SmallVectorImpl<char>
+  using SmallVectorImpl<char>::operator=;
+
   // Extra operators.
   const SmallString &operator=(StringRef RHS) {
     this->clear();
@@ -283,9 +255,15 @@ public:
   }
 
   SmallString &operator+=(StringRef RHS) {
-    this->append(RHS.begin(), RHS.end());
+    append(RHS.begin(), RHS.end());
     return *this;
   }
+
+  SmallString &operator+=(const SmallVectorImpl<char> &RHS) {
+    append(RHS.begin(), RHS.end());
+    return *this;
+  }
+
   SmallString &operator+=(char C) {
     this->push_back(C);
     return *this;
diff --git a/llvm/include/llvm/ADT/SmallVector.h b/llvm/include/llvm/ADT/SmallVector.h
index 2a5168c261f..e5e53d1dd65 100644
--- a/llvm/include/llvm/ADT/SmallVector.h
+++ b/llvm/include/llvm/ADT/SmallVector.h
@@ -451,10 +451,12 @@ public:
 
   void assign(unsigned NumElts, const T &Elt) {
     clear();
-    if (this->capacity() < NumElts)
-      this->grow(NumElts);
-    this->setEnd(this->begin()+NumElts);
-    std::uninitialized_fill(this->begin(), this->end(), Elt);
+    append(NumElts, Elt);
+  }
+
+  template <typename in_iter> void assign(in_iter S, in_iter E) {
+    clear();
+    append(S, E);
   }
 
   iterator erase(iterator I) {
diff --git a/llvm/include/llvm/DebugInfo/DIContext.h b/llvm/include/llvm/DebugInfo/DIContext.h
index f04dc001f4b..c20f1ea4505 100644
--- a/llvm/include/llvm/DebugInfo/DIContext.h
+++ b/llvm/include/llvm/DebugInfo/DIContext.h
@@ -50,8 +50,7 @@ public:
 
   bool operator==(const DILineInfo &RHS) const {
     return Line == RHS.Line && Column == RHS.Column &&
-           FileName.equals(RHS.FileName) &&
-           FunctionName.equals(RHS.FunctionName);
+           FileName == RHS.FileName && FunctionName == RHS.FunctionName;
   }
   bool operator!=(const DILineInfo &RHS) const {
     return !(*this == RHS);
diff --git a/llvm/unittests/ADT/SmallStringTest.cpp b/llvm/unittests/ADT/SmallStringTest.cpp
index 9398e99c911..ff04f5bd57f 100644
--- a/llvm/unittests/ADT/SmallStringTest.cpp
+++ b/llvm/unittests/ADT/SmallStringTest.cpp
@@ -50,13 +50,6 @@ TEST_F(SmallStringTest, AssignRepeated) {
   EXPECT_STREQ("aaa", theString.c_str());
 }
 
-TEST_F(SmallStringTest, AssignIterPair) {
-  StringRef abc = "abc";
-  theString.assign(abc.begin(), abc.end());
-  EXPECT_EQ(3u, theString.size());
-  EXPECT_STREQ("abc", theString.c_str());
-}
-
 TEST_F(SmallStringTest, AssignStringRef) {
   StringRef abc = "abc";
   theString.assign(abc);
@@ -88,6 +81,23 @@ TEST_F(SmallStringTest, AppendStringRef) {
   EXPECT_STREQ("abcabc", theString.c_str());
 }
 
+TEST_F(SmallStringTest, PlusEqualsStringRef) {
+  StringRef abc = "abc";
+  theString += abc;
+  theString += abc;
+  EXPECT_EQ(6u, theString.size());
+  EXPECT_STREQ("abcabc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, PlusEqualsSmallVector) {
+  StringRef abc = "abc";
+  SmallVector<char, 10> abcVec(abc.begin(), abc.end());
+  theString += abcVec;
+  theString += abcVec;
+  EXPECT_EQ(6u, theString.size());
+  EXPECT_STREQ("abcabc", theString.c_str());
+}
+
 TEST_F(SmallStringTest, AppendSmallVector) {
   StringRef abc = "abc";
   SmallVector<char, 10> abcVec(abc.begin(), abc.end());
diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp
index 90c7982699a..0ecb7987797 100644
--- a/llvm/unittests/ADT/SmallVectorTest.cpp
+++ b/llvm/unittests/ADT/SmallVectorTest.cpp
@@ -338,6 +338,17 @@ TYPED_TEST(SmallVectorTest, AssignTest) {
   this->assertValuesInOrder(this->theVector, 2u, 77, 77);
 }
 
+TYPED_TEST(SmallVectorTest, AssignIterPair) {
+  SCOPED_TRACE("AssignIterPair");
+
+  std::vector<int> v;
+  v.push_back(1);
+  v.push_back(2);
+  this->theVector.push_back(Constructable(1));
+  this->theVector.assign(v.begin(), v.end());
+  this->assertValuesInOrder(this->theVector, 2u, 1, 2);
+}
+
 // Erase a single element
 TYPED_TEST(SmallVectorTest, EraseTest) {
   SCOPED_TRACE("EraseTest");