1 files changed, 308 insertions, 236 deletions

diff --git a/include/llvm/ADT/SmallVector.h b/include/llvm/ADT/SmallVector.h
index b16649e..89acefd 100644
--- a/include/llvm/ADT/SmallVector.h
+++ b/include/llvm/ADT/SmallVector.h
@@ -80,55 +80,56 @@ protected:
     return BeginX == static_cast<const void*>(&FirstEl);
   }
   
+  /// size_in_bytes - This returns size()*sizeof(T).
+  size_t size_in_bytes() const {
+    return size_t((char*)EndX - (char*)BeginX);
+  }
+  
+  /// capacity_in_bytes - This returns capacity()*sizeof(T).
+  size_t capacity_in_bytes() const {
+    return size_t((char*)CapacityX - (char*)BeginX);
+  }
+  
+  /// grow_pod - This is an implementation of the grow() method which only works
+  /// on POD-like datatypes and is out of line to reduce code duplication.
+  void grow_pod(size_t MinSizeInBytes, size_t TSize);
   
 public:
   bool empty() const { return BeginX == EndX; }
 };
   
-/// SmallVectorImpl - This class consists of common code factored out of the
-/// SmallVector class to reduce code duplication based on the SmallVector 'N'
-/// template parameter.
+
 template <typename T>
-class SmallVectorImpl : public SmallVectorBase {
-  void setEnd(T *P) { EndX = P; }
+class SmallVectorTemplateCommon : public SmallVectorBase {
+protected:
+  void setEnd(T *P) { this->EndX = P; }
 public:
-  // Default ctor - Initialize to empty.
-  explicit SmallVectorImpl(unsigned N) : SmallVectorBase(N*sizeof(T)) {
-  }
-
-  ~SmallVectorImpl() {
-    // Destroy the constructed elements in the vector.
-    destroy_range(begin(), end());
-
-    // If this wasn't grown from the inline copy, deallocate the old space.
-    if (!isSmall())
-      operator delete(begin());
-  }
-
+  SmallVectorTemplateCommon(size_t Size) : SmallVectorBase(Size) {}
+  
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef T value_type;
   typedef T *iterator;
   typedef const T *const_iterator;
-
+  
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
   typedef std::reverse_iterator<iterator> reverse_iterator;
-
+  
   typedef T &reference;
   typedef const T &const_reference;
   typedef T *pointer;
   typedef const T *const_pointer;
-
+  
   // forward iterator creation methods.
-  iterator begin() { return (iterator)BeginX; }
-  const_iterator begin() const { return (const_iterator)BeginX; }
-  iterator end() { return (iterator)EndX; }
-  const_iterator end() const { return (const_iterator)EndX; }
-private:
-  iterator capacity_ptr() { return (iterator)CapacityX; }
-  const_iterator capacity_ptr() const { return (const_iterator)CapacityX; }
+  iterator begin() { return (iterator)this->BeginX; }
+  const_iterator begin() const { return (const_iterator)this->BeginX; }
+  iterator end() { return (iterator)this->EndX; }
+  const_iterator end() const { return (const_iterator)this->EndX; }
+protected:
+  iterator capacity_ptr() { return (iterator)this->CapacityX; }
+  const_iterator capacity_ptr() const { return (const_iterator)this->CapacityX;}
 public:
-
+  
   // reverse iterator creation methods.
   reverse_iterator rbegin()            { return reverse_iterator(end()); }
   const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
@@ -169,248 +170,359 @@ public:
   const_reference back() const {
     return end()[-1];
   }
+};
+  
+/// SmallVectorTemplateBase<isPodLike = false> - This is where we put method
+/// implementations that are designed to work with non-POD-like T's.
+template <typename T, bool isPodLike>
+class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
+public:
+  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
 
-  void push_back(const_reference Elt) {
-    if (EndX < CapacityX) {
-  Retry:
-      new (end()) T(Elt);
-      setEnd(end()+1);
-      return;
+  static void destroy_range(T *S, T *E) {
+    while (S != E) {
+      --E;
+      E->~T();
     }
-    grow();
-    goto Retry;
   }
-
-  void pop_back() {
-    setEnd(end()-1);
-    end()->~T();
+  
+  /// uninitialized_copy - Copy the range [I, E) onto the uninitialized memory
+  /// starting with "Dest", constructing elements into it as needed.
+  template<typename It1, typename It2>
+  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
+    std::uninitialized_copy(I, E, Dest);
   }
+  
+  /// grow - double the size of the allocated memory, guaranteeing space for at
+  /// least one more element or MinSize if specified.
+  void grow(size_t MinSize = 0);
+};
 
-  T pop_back_val() {
-    T Result = back();
-    pop_back();
-    return Result;
+// Define this out-of-line to dissuade the C++ compiler from inlining it.
+template <typename T, bool isPodLike>
+void SmallVectorTemplateBase<T, isPodLike>::grow(size_t MinSize) {
+  size_t CurCapacity = this->capacity();
+  size_t CurSize = this->size();
+  size_t NewCapacity = 2*CurCapacity;
+  if (NewCapacity < MinSize)
+    NewCapacity = MinSize;
+  T *NewElts = static_cast<T*>(operator new(NewCapacity*sizeof(T)));
+  
+  // Copy the elements over.
+  this->uninitialized_copy(this->begin(), this->end(), NewElts);
+  
+  // Destroy the original elements.
+  destroy_range(this->begin(), this->end());
+  
+  // If this wasn't grown from the inline copy, deallocate the old space.
+  if (!this->isSmall())
+    operator delete(this->begin());
+  
+  this->setEnd(NewElts+CurSize);
+  this->BeginX = NewElts;
+  this->CapacityX = this->begin()+NewCapacity;
+}
+  
+  
+/// SmallVectorTemplateBase<isPodLike = true> - This is where we put method
+/// implementations that are designed to work with POD-like T's.
+template <typename T>
+class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
+public:
+  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
+  
+  // No need to do a destroy loop for POD's.
+  static void destroy_range(T *, T *) {}
+  
+  /// uninitialized_copy - Copy the range [I, E) onto the uninitialized memory
+  /// starting with "Dest", constructing elements into it as needed.
+  template<typename It1, typename It2>
+  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
+    // Use memcpy for PODs: std::uninitialized_copy optimizes to memmove, memcpy
+    // is better.
+    memcpy(&*Dest, &*I, (E-I)*sizeof(T));
   }
-
+  
+  /// grow - double the size of the allocated memory, guaranteeing space for at
+  /// least one more element or MinSize if specified.
+  void grow(size_t MinSize = 0) {
+    this->grow_pod(MinSize*sizeof(T), sizeof(T));
+  }
+};
+  
+  
+/// SmallVectorImpl - This class consists of common code factored out of the
+/// SmallVector class to reduce code duplication based on the SmallVector 'N'
+/// template parameter.
+template <typename T>
+class SmallVectorImpl : public SmallVectorTemplateBase<T, isPodLike<T>::value> {
+  typedef SmallVectorTemplateBase<T, isPodLike<T>::value > SuperClass;
+public:
+  typedef typename SuperClass::iterator iterator;
+  typedef typename SuperClass::size_type size_type;
+  
+  // Default ctor - Initialize to empty.
+  explicit SmallVectorImpl(unsigned N)
+    : SmallVectorTemplateBase<T, isPodLike<T>::value>(N*sizeof(T)) {
+  }
+  
+  ~SmallVectorImpl() {
+    // Destroy the constructed elements in the vector.
+    this->destroy_range(this->begin(), this->end());
+    
+    // If this wasn't grown from the inline copy, deallocate the old space.
+    if (!this->isSmall())
+      operator delete(this->begin());
+  }
+  
+  
   void clear() {
-    destroy_range(begin(), end());
-    EndX = BeginX;
+    this->destroy_range(this->begin(), this->end());
+    this->EndX = this->BeginX;
   }
 
   void resize(unsigned N) {
-    if (N < size()) {
-      destroy_range(begin()+N, end());
-      setEnd(begin()+N);
-    } else if (N > size()) {
-      if (capacity() < N)
-        grow(N);
-      construct_range(end(), begin()+N, T());
-      setEnd(begin()+N);
+    if (N < this->size()) {
+      this->destroy_range(this->begin()+N, this->end());
+      this->setEnd(this->begin()+N);
+    } else if (N > this->size()) {
+      if (this->capacity() < N)
+        this->grow(N);
+      this->construct_range(this->end(), this->begin()+N, T());
+      this->setEnd(this->begin()+N);
     }
   }
 
   void resize(unsigned N, const T &NV) {
-    if (N < size()) {
-      destroy_range(begin()+N, end());
-      setEnd(begin()+N);
-    } else if (N > size()) {
-      if (capacity() < N)
-        grow(N);
-      construct_range(end(), begin()+N, NV);
-      setEnd(begin()+N);
+    if (N < this->size()) {
+      this->destroy_range(this->begin()+N, this->end());
+      this->setEnd(this->begin()+N);
+    } else if (N > this->size()) {
+      if (this->capacity() < N)
+        this->grow(N);
+      construct_range(this->end(), this->begin()+N, NV);
+      this->setEnd(this->begin()+N);
     }
   }
 
   void reserve(unsigned N) {
-    if (capacity() < N)
-      grow(N);
+    if (this->capacity() < N)
+      this->grow(N);
   }
-
+  
+  void push_back(const T &Elt) {
+    if (this->EndX < this->CapacityX) {
+    Retry:
+      new (this->end()) T(Elt);
+      this->setEnd(this->end()+1);
+      return;
+    }
+    this->grow();
+    goto Retry;
+  }
+  
+  void pop_back() {
+    this->setEnd(this->end()-1);
+    this->end()->~T();
+  }
+  
+  T pop_back_val() {
+    T Result = this->back();
+    pop_back();
+    return Result;
+  }
+  
+  
   void swap(SmallVectorImpl &RHS);
-
+  
   /// append - Add the specified range to the end of the SmallVector.
   ///
   template<typename in_iter>
   void append(in_iter in_start, in_iter in_end) {
     size_type NumInputs = std::distance(in_start, in_end);
     // Grow allocated space if needed.
-    if (NumInputs > size_type(capacity_ptr()-end()))
-      grow(size()+NumInputs);
-
+    if (NumInputs > size_type(this->capacity_ptr()-this->end()))
+      this->grow(this->size()+NumInputs);
+    
     // Copy the new elements over.
-    std::uninitialized_copy(in_start, in_end, end());
-    setEnd(end() + NumInputs);
+    // TODO: NEED To compile time dispatch on whether in_iter is a random access
+    // iterator to use the fast uninitialized_copy.
+    std::uninitialized_copy(in_start, in_end, this->end());
+    this->setEnd(this->end() + NumInputs);
   }
-
+  
   /// append - Add the specified range to the end of the SmallVector.
   ///
   void append(size_type NumInputs, const T &Elt) {
     // Grow allocated space if needed.
-    if (NumInputs > size_type(capacity_ptr()-end()))
-      grow(size()+NumInputs);
-
+    if (NumInputs > size_type(this->capacity_ptr()-this->end()))
+      this->grow(this->size()+NumInputs);
+    
     // Copy the new elements over.
-    std::uninitialized_fill_n(end(), NumInputs, Elt);
-    setEnd(end() + NumInputs);
+    std::uninitialized_fill_n(this->end(), NumInputs, Elt);
+    this->setEnd(this->end() + NumInputs);
   }
-
+  
   void assign(unsigned NumElts, const T &Elt) {
     clear();
-    if (capacity() < NumElts)
-      grow(NumElts);
-    setEnd(begin()+NumElts);
-    construct_range(begin(), end(), Elt);
+    if (this->capacity() < NumElts)
+      this->grow(NumElts);
+    this->setEnd(this->begin()+NumElts);
+    construct_range(this->begin(), this->end(), Elt);
   }
-
+  
   iterator erase(iterator I) {
     iterator N = I;
     // Shift all elts down one.
-    std::copy(I+1, end(), I);
+    std::copy(I+1, this->end(), I);
     // Drop the last elt.
     pop_back();
     return(N);
   }
-
+  
   iterator erase(iterator S, iterator E) {
     iterator N = S;
     // Shift all elts down.
-    iterator I = std::copy(E, end(), S);
+    iterator I = std::copy(E, this->end(), S);
     // Drop the last elts.
-    destroy_range(I, end());
-    setEnd(I);
+    this->destroy_range(I, this->end());
+    this->setEnd(I);
     return(N);
   }
-
+  
   iterator insert(iterator I, const T &Elt) {
-    if (I == end()) {  // Important special case for empty vector.
+    if (I == this->end()) {  // Important special case for empty vector.
       push_back(Elt);
-      return end()-1;
+      return this->end()-1;
     }
-
-    if (EndX < CapacityX) {
-  Retry:
-      new (end()) T(back());
-      setEnd(end()+1);
+    
+    if (this->EndX < this->CapacityX) {
+    Retry:
+      new (this->end()) T(this->back());
+      this->setEnd(this->end()+1);
       // Push everything else over.
-      std::copy_backward(I, end()-1, end());
+      std::copy_backward(I, this->end()-1, this->end());
       *I = Elt;
       return I;
     }
-    size_t EltNo = I-begin();
-    grow();
-    I = begin()+EltNo;
+    size_t EltNo = I-this->begin();
+    this->grow();
+    I = this->begin()+EltNo;
     goto Retry;
   }
-
+  
   iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
-    if (I == end()) {  // Important special case for empty vector.
+    if (I == this->end()) {  // Important special case for empty vector.
       append(NumToInsert, Elt);
-      return end()-1;
+      return this->end()-1;
     }
-
+    
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    size_t InsertElt = I-begin();
-
+    size_t InsertElt = I - this->begin();
+    
     // Ensure there is enough space.
-    reserve(static_cast<unsigned>(size() + NumToInsert));
-
+    reserve(static_cast<unsigned>(this->size() + NumToInsert));
+    
     // Uninvalidate the iterator.
-    I = begin()+InsertElt;
-
+    I = this->begin()+InsertElt;
+    
     // If there are more elements between the insertion point and the end of the
     // range than there are being inserted, we can use a simple approach to
     // insertion.  Since we already reserved space, we know that this won't
     // reallocate the vector.
-    if (size_t(end()-I) >= NumToInsert) {
-      T *OldEnd = end();
-      append(end()-NumToInsert, end());
-
+    if (size_t(this->end()-I) >= NumToInsert) {
+      T *OldEnd = this->end();
+      append(this->end()-NumToInsert, this->end());
+      
       // Copy the existing elements that get replaced.
       std::copy_backward(I, OldEnd-NumToInsert, OldEnd);
-
+      
       std::fill_n(I, NumToInsert, Elt);
       return I;
     }
-
+    
     // Otherwise, we're inserting more elements than exist already, and we're
     // not inserting at the end.
-
+    
     // Copy over the elements that we're about to overwrite.
-    T *OldEnd = end();
-    setEnd(end() + NumToInsert);
+    T *OldEnd = this->end();
+    this->setEnd(this->end() + NumToInsert);
     size_t NumOverwritten = OldEnd-I;
-    std::uninitialized_copy(I, OldEnd, end()-NumOverwritten);
-
+    this->uninitialized_copy(I, OldEnd, this->end()-NumOverwritten);
+    
     // Replace the overwritten part.
     std::fill_n(I, NumOverwritten, Elt);
-
+    
     // Insert the non-overwritten middle part.
     std::uninitialized_fill_n(OldEnd, NumToInsert-NumOverwritten, Elt);
     return I;
   }
-
+  
   template<typename ItTy>
   iterator insert(iterator I, ItTy From, ItTy To) {
-    if (I == end()) {  // Important special case for empty vector.
+    if (I == this->end()) {  // Important special case for empty vector.
       append(From, To);
-      return end()-1;
+      return this->end()-1;
     }
-
+    
     size_t NumToInsert = std::distance(From, To);
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    size_t InsertElt = I-begin();
-
+    size_t InsertElt = I - this->begin();
+    
     // Ensure there is enough space.
-    reserve(static_cast<unsigned>(size() + NumToInsert));
-
+    reserve(static_cast<unsigned>(this->size() + NumToInsert));
+    
     // Uninvalidate the iterator.
-    I = begin()+InsertElt;
-
+    I = this->begin()+InsertElt;
+    
     // If there are more elements between the insertion point and the end of the
     // range than there are being inserted, we can use a simple approach to
     // insertion.  Since we already reserved space, we know that this won't
     // reallocate the vector.
-    if (size_t(end()-I) >= NumToInsert) {
-      T *OldEnd = end();
-      append(end()-NumToInsert, end());
-
+    if (size_t(this->end()-I) >= NumToInsert) {
+      T *OldEnd = this->end();
+      append(this->end()-NumToInsert, this->end());
+      
       // Copy the existing elements that get replaced.
       std::copy_backward(I, OldEnd-NumToInsert, OldEnd);
-
+      
       std::copy(From, To, I);
       return I;
     }
-
+    
     // Otherwise, we're inserting more elements than exist already, and we're
     // not inserting at the end.
-
+    
     // Copy over the elements that we're about to overwrite.
-    T *OldEnd = end();
-    setEnd(end() + NumToInsert);
+    T *OldEnd = this->end();
+    this->setEnd(this->end() + NumToInsert);
     size_t NumOverwritten = OldEnd-I;
-    std::uninitialized_copy(I, OldEnd, end()-NumOverwritten);
-
+    this->uninitialized_copy(I, OldEnd, this->end()-NumOverwritten);
+    
     // Replace the overwritten part.
     std::copy(From, From+NumOverwritten, I);
-
+    
     // Insert the non-overwritten middle part.
-    std::uninitialized_copy(From+NumOverwritten, To, OldEnd);
+    this->uninitialized_copy(From+NumOverwritten, To, OldEnd);
     return I;
   }
-
-  const SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
-
+  
+  const SmallVectorImpl
+  &operator=(const SmallVectorImpl &RHS);
+  
   bool operator==(const SmallVectorImpl &RHS) const {
-    if (size() != RHS.size()) return false;
-    return std::equal(begin(), end(), RHS.begin());
+    if (this->size() != RHS.size()) return false;
+    return std::equal(this->begin(), this->end(), RHS.begin());
   }
-  bool operator!=(const SmallVectorImpl &RHS) const { return !(*this == RHS); }
-
+  bool operator!=(const SmallVectorImpl &RHS) const {
+    return !(*this == RHS);
+  }
+  
   bool operator<(const SmallVectorImpl &RHS) const {
-    return std::lexicographical_compare(begin(), end(),
+    return std::lexicographical_compare(this->begin(), this->end(),
                                         RHS.begin(), RHS.end());
   }
-
+  
   /// set_size - Set the array size to \arg N, which the current array must have
   /// enough capacity for.
   ///
@@ -421,145 +533,105 @@ public:
   /// update the size later. This avoids the cost of value initializing elements
   /// which will only be overwritten.
   void set_size(unsigned N) {
-    assert(N <= capacity());
-    setEnd(begin() + N);
+    assert(N <= this->capacity());
+    this->setEnd(this->begin() + N);
   }
-
+  
 private:
-  /// grow - double the size of the allocated memory, guaranteeing space for at
-  /// least one more element or MinSize if specified.
-  void grow(size_type MinSize = 0);
-
-  void construct_range(T *S, T *E, const T &Elt) {
+  static void construct_range(T *S, T *E, const T &Elt) {
     for (; S != E; ++S)
       new (S) T(Elt);
   }
-
-  void destroy_range(T *S, T *E) {
-    // No need to do a destroy loop for POD's.
-    if (isPodLike<T>::value) return;
-    
-    while (S != E) {
-      --E;
-      E->~T();
-    }
-  }
 };
-
-// Define this out-of-line to dissuade the C++ compiler from inlining it.
-template <typename T>
-void SmallVectorImpl<T>::grow(size_t MinSize) {
-  size_t CurCapacity = capacity();
-  size_t CurSize = size();
-  size_t NewCapacity = 2*CurCapacity;
-  if (NewCapacity < MinSize)
-    NewCapacity = MinSize;
-  T *NewElts = static_cast<T*>(operator new(NewCapacity*sizeof(T)));
-
-  // Copy the elements over.
-  if (isPodLike<T>::value)
-    // Use memcpy for PODs: std::uninitialized_copy optimizes to memmove.
-    memcpy(NewElts, begin(), CurSize * sizeof(T));
-  else
-    std::uninitialized_copy(begin(), end(), NewElts);
-
-  // Destroy the original elements.
-  destroy_range(begin(), end());
-
-  // If this wasn't grown from the inline copy, deallocate the old space.
-  if (!isSmall())
-    operator delete(begin());
-
-  setEnd(NewElts+CurSize);
-  BeginX = NewElts;
-  CapacityX = begin()+NewCapacity;
-}
+  
 
 template <typename T>
 void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
   if (this == &RHS) return;
 
   // We can only avoid copying elements if neither vector is small.
-  if (!isSmall() && !RHS.isSmall()) {
-    std::swap(BeginX, RHS.BeginX);
-    std::swap(EndX, RHS.EndX);
-    std::swap(CapacityX, RHS.CapacityX);
+  if (!this->isSmall() && !RHS.isSmall()) {
+    std::swap(this->BeginX, RHS.BeginX);
+    std::swap(this->EndX, RHS.EndX);
+    std::swap(this->CapacityX, RHS.CapacityX);
     return;
   }
-  if (RHS.size() > capacity())
-    grow(RHS.size());
-  if (size() > RHS.capacity())
-    RHS.grow(size());
+  if (RHS.size() > this->capacity())
+    this->grow(RHS.size());
+  if (this->size() > RHS.capacity())
+    RHS.grow(this->size());
 
   // Swap the shared elements.
-  size_t NumShared = size();
+  size_t NumShared = this->size();
   if (NumShared > RHS.size()) NumShared = RHS.size();
   for (unsigned i = 0; i != static_cast<unsigned>(NumShared); ++i)
     std::swap((*this)[i], RHS[i]);
 
   // Copy over the extra elts.
-  if (size() > RHS.size()) {
-    size_t EltDiff = size() - RHS.size();
-    std::uninitialized_copy(begin()+NumShared, end(), RHS.end());
+  if (this->size() > RHS.size()) {
+    size_t EltDiff = this->size() - RHS.size();
+    this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
     RHS.setEnd(RHS.end()+EltDiff);
-    destroy_range(begin()+NumShared, end());
-    setEnd(begin()+NumShared);
-  } else if (RHS.size() > size()) {
-    size_t EltDiff = RHS.size() - size();
-    std::uninitialized_copy(RHS.begin()+NumShared, RHS.end(), end());
-    setEnd(end() + EltDiff);
-    destroy_range(RHS.begin()+NumShared, RHS.end());
+    this->destroy_range(this->begin()+NumShared, this->end());
+    this->setEnd(this->begin()+NumShared);
+  } else if (RHS.size() > this->size()) {
+    size_t EltDiff = RHS.size() - this->size();
+    this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
+    this->setEnd(this->end() + EltDiff);
+    this->destroy_range(RHS.begin()+NumShared, RHS.end());
     RHS.setEnd(RHS.begin()+NumShared);
   }
 }
 
 template <typename T>
-const SmallVectorImpl<T> &
-SmallVectorImpl<T>::operator=(const SmallVectorImpl<T> &RHS) {
+const SmallVectorImpl<T> &SmallVectorImpl<T>::
+  operator=(const SmallVectorImpl<T> &RHS) {
   // Avoid self-assignment.
   if (this == &RHS) return *this;
 
   // If we already have sufficient space, assign the common elements, then
   // destroy any excess.
   size_t RHSSize = RHS.size();
-  size_t CurSize = size();
+  size_t CurSize = this->size();
   if (CurSize >= RHSSize) {
     // Assign common elements.
     iterator NewEnd;
     if (RHSSize)
-      NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, begin());
+      NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
     else
-      NewEnd = begin();
+      NewEnd = this->begin();
 
     // Destroy excess elements.
-    destroy_range(NewEnd, end());
+    this->destroy_range(NewEnd, this->end());
 
     // Trim.
-    setEnd(NewEnd);
+    this->setEnd(NewEnd);
     return *this;
   }
 
   // If we have to grow to have enough elements, destroy the current elements.
   // This allows us to avoid copying them during the grow.
-  if (capacity() < RHSSize) {
+  if (this->capacity() < RHSSize) {
     // Destroy current elements.
-    destroy_range(begin(), end());
-    setEnd(begin());
+    this->destroy_range(this->begin(), this->end());
+    this->setEnd(this->begin());
     CurSize = 0;
-    grow(RHSSize);
+    this->grow(RHSSize);
   } else if (CurSize) {
     // Otherwise, use assignment for the already-constructed elements.
-    std::copy(RHS.begin(), RHS.begin()+CurSize, begin());
+    std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
   }
 
   // Copy construct the new elements in place.
-  std::uninitialized_copy(RHS.begin()+CurSize, RHS.end(), begin()+CurSize);
+  this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
+                           this->begin()+CurSize);
 
   // Set end.
-  setEnd(begin()+RHSSize);
+  this->setEnd(this->begin()+RHSSize);
   return *this;
 }
 
+
 /// SmallVector - This is a 'vector' (really, a variable-sized array), optimized
 /// for the case when the array is small.  It contains some number of elements
 /// in-place, which allows it to avoid heap allocation when the actual number of