[llvm] r211259 - Remove OwningPtr.h and associated tests

[Rafael Avila de Espindola]

Awesome, thanks!

Sent from my iPhone

> On Jun 19, 2014, at 3:25, Alp Toker <alp at nuanti.com> wrote:
> 
> Author: alp
> Date: Thu Jun 19 02:25:18 2014
> New Revision: 211259
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=211259&view=rev
> Log:
> Remove OwningPtr.h and associated tests
> 
> llvm::OwningPtr is superseded by std::unique_ptr.
> 
> Removed:
>    llvm/trunk/include/llvm/ADT/OwningPtr.h
>    llvm/trunk/unittests/ADT/OwningPtrTest.cpp
> Modified:
>    llvm/trunk/unittests/ADT/CMakeLists.txt
>    llvm/trunk/utils/llvm.natvis
> 
> Removed: llvm/trunk/include/llvm/ADT/OwningPtr.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/OwningPtr.h?rev=211258&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/OwningPtr.h (original)
> +++ llvm/trunk/include/llvm/ADT/OwningPtr.h (removed)
> @@ -1,165 +0,0 @@
> -//===- llvm/ADT/OwningPtr.h - Smart ptr that owns the pointee ---*- C++ -*-===//
> -//
> -//                     The LLVM Compiler Infrastructure
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
> -//===----------------------------------------------------------------------===//
> -//
> -// This file defines and implements the OwningPtr class.
> -//
> -//===----------------------------------------------------------------------===//
> -
> -#ifndef LLVM_ADT_OWNINGPTR_H
> -#define LLVM_ADT_OWNINGPTR_H
> -
> -#include "llvm/Support/Compiler.h"
> -#include <cassert>
> -#include <cstddef>
> -#include <memory>
> -
> -namespace llvm {
> -
> -/// OwningPtr smart pointer - OwningPtr mimics a built-in pointer except that it
> -/// guarantees deletion of the object pointed to, either on destruction of the
> -/// OwningPtr or via an explicit reset().  Once created, ownership of the
> -/// pointee object can be taken away from OwningPtr by using the take method.
> -template<class T>
> -class OwningPtr {
> -  OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION;
> -  OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION;
> -  T *Ptr;
> -public:
> -  explicit OwningPtr(T *P = 0) : Ptr(P) {}
> -
> -  OwningPtr(OwningPtr &&Other) : Ptr(Other.take()) {}
> -
> -  OwningPtr &operator=(OwningPtr &&Other) {
> -    reset(Other.take());
> -    return *this;
> -  }
> -
> -  OwningPtr(std::unique_ptr<T> Other) : Ptr(Other.release()) {}
> -
> -  OwningPtr &operator=(std::unique_ptr<T> Other) {
> -    reset(Other.release());
> -    return *this;
> -  }
> -
> -#if LLVM_HAS_RVALUE_REFERENCE_THIS
> -  operator std::unique_ptr<T>() && { return std::unique_ptr<T>(take()); }
> -#endif
> -
> -  ~OwningPtr() {
> -    delete Ptr;
> -  }
> -
> -  /// reset - Change the current pointee to the specified pointer.  Note that
> -  /// calling this with any pointer (including a null pointer) deletes the
> -  /// current pointer.
> -  void reset(T *P = 0) {
> -    if (P == Ptr) return;
> -    T *Tmp = Ptr;
> -    Ptr = P;
> -    delete Tmp;
> -  }
> -
> -  /// take - Reset the owning pointer to null and return its pointer.  This does
> -  /// not delete the pointer before returning it.
> -  T *take() {
> -    T *Tmp = Ptr;
> -    Ptr = nullptr;
> -    return Tmp;
> -  }
> -
> -  T *release() { return take(); }
> -
> -  std::unique_ptr<T> take_unique() { return std::unique_ptr<T>(take()); }
> -
> -  T &operator*() const {
> -    assert(Ptr && "Cannot dereference null pointer");
> -    return *Ptr;
> -  }
> -
> -  T *operator->() const { return Ptr; }
> -  T *get() const { return Ptr; }
> -  LLVM_EXPLICIT operator bool() const { return Ptr != nullptr; }
> -  bool operator!() const { return Ptr == nullptr; }
> -  bool isValid() const { return Ptr != nullptr; }
> -
> -  void swap(OwningPtr &RHS) {
> -    T *Tmp = RHS.Ptr;
> -    RHS.Ptr = Ptr;
> -    Ptr = Tmp;
> -  }
> -};
> -
> -template<class T>
> -inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
> -  a.swap(b);
> -}
> -
> -/// OwningArrayPtr smart pointer - OwningArrayPtr provides the same
> -///  functionality as OwningPtr, except that it works for array types.
> -template<class T>
> -class OwningArrayPtr {
> -  OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
> -  OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
> -  T *Ptr;
> -public:
> -  explicit OwningArrayPtr(T *P = 0) : Ptr(P) {}
> -
> -  OwningArrayPtr(OwningArrayPtr &&Other) : Ptr(Other.take()) {}
> -
> -  OwningArrayPtr &operator=(OwningArrayPtr &&Other) {
> -    reset(Other.take());
> -    return *this;
> -  }
> -
> -  ~OwningArrayPtr() {
> -    delete [] Ptr;
> -  }
> -
> -  /// reset - Change the current pointee to the specified pointer.  Note that
> -  /// calling this with any pointer (including a null pointer) deletes the
> -  /// current pointer.
> -  void reset(T *P = 0) {
> -    if (P == Ptr) return;
> -    T *Tmp = Ptr;
> -    Ptr = P;
> -    delete [] Tmp;
> -  }
> -
> -  /// take - Reset the owning pointer to null and return its pointer.  This does
> -  /// not delete the pointer before returning it.
> -  T *take() {
> -    T *Tmp = Ptr;
> -    Ptr = 0;
> -    return Tmp;
> -  }
> -
> -  T &operator[](std::ptrdiff_t i) const {
> -    assert(Ptr && "Cannot dereference null pointer");
> -    return Ptr[i];
> -  }
> -
> -  T *get() const { return Ptr; }
> -  LLVM_EXPLICIT operator bool() const { return Ptr != 0; }
> -  bool operator!() const { return Ptr == nullptr; }
> -
> -  void swap(OwningArrayPtr &RHS) {
> -    T *Tmp = RHS.Ptr;
> -    RHS.Ptr = Ptr;
> -    Ptr = Tmp;
> -  }
> -};
> -
> -template<class T>
> -inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
> -  a.swap(b);
> -}
> -
> -} // end namespace llvm
> -
> -#endif
> 
> Modified: llvm/trunk/unittests/ADT/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ADT/CMakeLists.txt?rev=211259&r1=211258&r2=211259&view=diff
> ==============================================================================
> --- llvm/trunk/unittests/ADT/CMakeLists.txt (original)
> +++ llvm/trunk/unittests/ADT/CMakeLists.txt Thu Jun 19 02:25:18 2014
> @@ -23,7 +23,6 @@ set(ADTSources
>   MakeUniqueTest.cpp
>   MapVectorTest.cpp
>   OptionalTest.cpp
> -  OwningPtrTest.cpp
>   PackedVectorTest.cpp
>   PointerIntPairTest.cpp
>   PointerUnionTest.cpp
> 
> Removed: llvm/trunk/unittests/ADT/OwningPtrTest.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ADT/OwningPtrTest.cpp?rev=211258&view=auto
> ==============================================================================
> --- llvm/trunk/unittests/ADT/OwningPtrTest.cpp (original)
> +++ llvm/trunk/unittests/ADT/OwningPtrTest.cpp (removed)
> @@ -1,273 +0,0 @@
> -//===- llvm/unittest/ADT/OwningPtrTest.cpp - OwningPtr unit tests ---------===//
> -//
> -//                     The LLVM Compiler Infrastructure
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
> -//===----------------------------------------------------------------------===//
> -
> -#include "llvm/ADT/OwningPtr.h"
> -#include "gtest/gtest.h"
> -using namespace llvm;
> -
> -namespace {
> -
> -struct TrackDestructor {
> -  static unsigned Destructions;
> -  int val;
> -  explicit TrackDestructor(int val) : val(val) {}
> -  ~TrackDestructor() { ++Destructions; }
> -  static void ResetCounts() { Destructions = 0; }
> -
> -private:
> -  TrackDestructor(const TrackDestructor &other) LLVM_DELETED_FUNCTION;
> -  TrackDestructor &
> -  operator=(const TrackDestructor &other) LLVM_DELETED_FUNCTION;
> -  TrackDestructor(TrackDestructor &&other) LLVM_DELETED_FUNCTION;
> -  TrackDestructor &operator=(TrackDestructor &&other) LLVM_DELETED_FUNCTION;
> -};
> -
> -unsigned TrackDestructor::Destructions = 0;
> -
> -// Test fixture
> -class OwningPtrTest : public testing::Test {};
> -
> -TEST_F(OwningPtrTest, DefaultConstruction) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> O;
> -    EXPECT_FALSE(O);
> -    EXPECT_TRUE(!O);
> -    EXPECT_FALSE(O.get());
> -    EXPECT_FALSE(O.isValid());
> -  }
> -  EXPECT_EQ(0u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, PtrConstruction) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> O(new TrackDestructor(3));
> -    EXPECT_TRUE((bool)O);
> -    EXPECT_FALSE(!O);
> -    EXPECT_TRUE(O.get());
> -    EXPECT_TRUE(O.isValid());
> -    EXPECT_EQ(3, (*O).val);
> -    EXPECT_EQ(3, O->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, Reset) {
> -  TrackDestructor::ResetCounts();
> -  OwningPtr<TrackDestructor> O(new TrackDestructor(3));
> -  EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  O.reset();
> -  EXPECT_FALSE((bool)O);
> -  EXPECT_TRUE(!O);
> -  EXPECT_FALSE(O.get());
> -  EXPECT_FALSE(O.isValid());
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, Take) {
> -  TrackDestructor::ResetCounts();
> -  TrackDestructor *T = nullptr;
> -  {
> -    OwningPtr<TrackDestructor> O(new TrackDestructor(3));
> -    T = O.take();
> -    EXPECT_FALSE((bool)O);
> -    EXPECT_TRUE(!O);
> -    EXPECT_FALSE(O.get());
> -    EXPECT_FALSE(O.isValid());
> -    EXPECT_TRUE(T);
> -    EXPECT_EQ(3, T->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  delete T;
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, Release) {
> -  TrackDestructor::ResetCounts();
> -  TrackDestructor *T = nullptr;
> -  {
> -    OwningPtr<TrackDestructor> O(new TrackDestructor(3));
> -    T = O.release();
> -    EXPECT_FALSE((bool)O);
> -    EXPECT_TRUE(!O);
> -    EXPECT_FALSE(O.get());
> -    EXPECT_FALSE(O.isValid());
> -    EXPECT_TRUE(T);
> -    EXPECT_EQ(3, T->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  delete T;
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, MoveConstruction) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> A(new TrackDestructor(3));
> -    OwningPtr<TrackDestructor> B = std::move(A);
> -    EXPECT_FALSE((bool)A);
> -    EXPECT_TRUE(!A);
> -    EXPECT_FALSE(A.get());
> -    EXPECT_FALSE(A.isValid());
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_TRUE(B.isValid());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, MoveAssignment) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> A(new TrackDestructor(3));
> -    OwningPtr<TrackDestructor> B(new TrackDestructor(4));
> -    B = std::move(A);
> -    EXPECT_FALSE(A);
> -    EXPECT_TRUE(!A);
> -    EXPECT_FALSE(A.get());
> -    EXPECT_FALSE(A.isValid());
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_TRUE(B.isValid());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(1u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(2u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, Swap) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> A(new TrackDestructor(3));
> -    OwningPtr<TrackDestructor> B(new TrackDestructor(4));
> -    B.swap(A);
> -    EXPECT_TRUE((bool)A);
> -    EXPECT_FALSE(!A);
> -    EXPECT_TRUE(A.get());
> -    EXPECT_TRUE(A.isValid());
> -    EXPECT_EQ(4, (*A).val);
> -    EXPECT_EQ(4, A->val);
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_TRUE(B.isValid());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(2u, TrackDestructor::Destructions);
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> A(new TrackDestructor(3));
> -    OwningPtr<TrackDestructor> B(new TrackDestructor(4));
> -    swap(A, B);
> -    EXPECT_TRUE((bool)A);
> -    EXPECT_FALSE(!A);
> -    EXPECT_TRUE(A.get());
> -    EXPECT_TRUE(A.isValid());
> -    EXPECT_EQ(4, (*A).val);
> -    EXPECT_EQ(4, A->val);
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_TRUE(B.isValid());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(2u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, UniqueToOwningConstruction) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
> -    OwningPtr<TrackDestructor> B = std::move(A);
> -    EXPECT_FALSE(A);
> -    EXPECT_TRUE(!A);
> -    EXPECT_FALSE(A.get());
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_TRUE(B.isValid());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, UniqueToOwningAssignment) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    std::unique_ptr<TrackDestructor> A(new TrackDestructor(3));
> -    OwningPtr<TrackDestructor> B(new TrackDestructor(4));
> -    B = std::move(A);
> -    EXPECT_FALSE(A);
> -    EXPECT_TRUE(!A);
> -    EXPECT_FALSE(A.get());
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_TRUE(B.isValid());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(1u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(2u, TrackDestructor::Destructions);
> -}
> -
> -TEST_F(OwningPtrTest, TakeUniqueConstruction) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> A(new TrackDestructor(3));
> -    std::unique_ptr<TrackDestructor> B = A.take_unique();
> -    EXPECT_FALSE(A);
> -    EXPECT_TRUE(!A);
> -    EXPECT_FALSE(A.get());
> -    EXPECT_FALSE(A.isValid());
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -
> -#if LLVM_HAS_RVALUE_REFERENCE_THIS
> -TEST_F(OwningPtrTest, OwningToUniqueConstruction) {
> -  TrackDestructor::ResetCounts();
> -  {
> -    OwningPtr<TrackDestructor> A(new TrackDestructor(3));
> -    std::unique_ptr<TrackDestructor> B = std::move(A);
> -    EXPECT_FALSE(A);
> -    EXPECT_TRUE(!A);
> -    EXPECT_FALSE(A.get());
> -    EXPECT_FALSE(A.isValid());
> -    EXPECT_TRUE((bool)B);
> -    EXPECT_FALSE(!B);
> -    EXPECT_TRUE(B.get());
> -    EXPECT_EQ(3, (*B).val);
> -    EXPECT_EQ(3, B->val);
> -    EXPECT_EQ(0u, TrackDestructor::Destructions);
> -  }
> -  EXPECT_EQ(1u, TrackDestructor::Destructions);
> -}
> -#endif
> -}
> 
> Modified: llvm/trunk/utils/llvm.natvis
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/llvm.natvis?rev=211259&r1=211258&r2=211259&view=diff
> ==============================================================================
> --- llvm/trunk/utils/llvm.natvis (original)
> +++ llvm/trunk/utils/llvm.natvis Thu Jun 19 02:25:18 2014
> @@ -108,14 +108,6 @@ or create a symbolic link so it updates
>     </Expand>
>   </Type>
> 
> -  <Type Name="llvm::OwningPtr<*>">
> -    <DisplayString Condition="Ptr == 0">empty</DisplayString>
> -    <DisplayString Condition="Ptr != 0">OwningPtr {*Ptr}</DisplayString>
> -    <Expand>
> -      <ExpandedItem Condition="Ptr != 0">Ptr</ExpandedItem>
> -    </Expand>
> -  </Type>
> -
>   <Type Name="llvm::SmallPtrSet<*,*>">
>     <DisplayString Condition="CurArray == SmallArray">{{ [Small Mode] size={NumElements}, capacity={CurArraySize} }}</DisplayString>
>     <DisplayString Condition="CurArray != SmallArray">{{ [Big Mode] size={NumElements}, capacity={CurArraySize} }}</DisplayString>
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits