[PATCH] Deprecate and remove OwningPtr
Alp Toker
alp at nuanti.com
Wed Jun 18 23:52:58 PDT 2014
On 19/06/2014 09:33, Aaron Ballman wrote:
> On Thu, Jun 19, 2014 at 1:30 AM, Alp Toker <alp at nuanti.com> wrote:
>> The attached patch slaps some deprecation attributes on the OwningPtr
>> classes and removes associated unit tests.
>>
>> I'll follow up and remove the OwningPtr.h header completely a couple of days
>> after to provide a last-chance grace period.
> "A couple of days" is not exactly a grace period, especially given how
> many folks are at the standards meetings currently. Was this grace
> period discussed at some point?
I don't think we've attempted to provide any deprecation period before.
We usually remove dead code from the LLVM internal headers immediately
along with its last use.
>> commit c68306ca9483bbed6bf49a21da989517f081bef3
>> Author: Alp Toker <alp at nuanti.com>
>> Date: Thu Jun 19 08:09:43 2014 +0300
>>
>> Deprecate OwningPtr pending imminent removal
>>
>> diff --git a/include/llvm/ADT/OwningPtr.h b/include/llvm/ADT/OwningPtr.h
>> index 5e83358..02ad512 100644
>> --- a/include/llvm/ADT/OwningPtr.h
>> +++ b/include/llvm/ADT/OwningPtr.h
>> @@ -26,7 +26,7 @@ namespace llvm {
>> /// 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 {
>> +class [[deprecated]] OwningPtr {
> Not all of our supported compilers also supports C++11-style
> attributes, so this approach is untenable.
Okay. Attached patch removes OwningPtr.h and related facilities completely.
Alp.
>
>> OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION;
>> OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION;
>> T *Ptr;
>> @@ -96,6 +96,7 @@ public:
>> };
>>
>> template<class T>
>> +[[deprecated]]
>> inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
>> a.swap(b);
>> }
>> @@ -103,7 +104,7 @@ inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
>> /// OwningArrayPtr smart pointer - OwningArrayPtr provides the same
>> /// functionality as OwningPtr, except that it works for array types.
>> template<class T>
>> -class OwningArrayPtr {
>> +class [[deprecated]] OwningArrayPtr {
>> OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
>> OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
>> T *Ptr;
>> @@ -156,6 +157,7 @@ public:
>> };
>>
>> template<class T>
>> +[[deprecated]]
>> inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
>> a.swap(b);
>> }
>> diff --git a/unittests/ADT/CMakeLists.txt b/unittests/ADT/CMakeLists.txt
>> index 5119723..0f214f3 100644
>> --- a/unittests/ADT/CMakeLists.txt
>> +++ b/unittests/ADT/CMakeLists.txt
>> @@ -23,7 +23,6 @@ set(ADTSources
>> MakeUniqueTest.cpp
>> MapVectorTest.cpp
>> OptionalTest.cpp
>> - OwningPtrTest.cpp
>> PackedVectorTest.cpp
>> PointerIntPairTest.cpp
>> PointerUnionTest.cpp
>> diff --git a/unittests/ADT/OwningPtrTest.cpp b/unittests/ADT/OwningPtrTest.cpp
>> deleted file mode 100644
>> index d83a947..0000000
>> --- a/unittests/ADT/OwningPtrTest.cpp
>> +++ /dev/null
>> @@ -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
>> -}
>>
> ~Aaron
--
http://www.nuanti.com
the browser experts
-------------- next part --------------
diff --git a/include/llvm/ADT/OwningPtr.h b/include/llvm/ADT/OwningPtr.h
deleted file mode 100644
index 5e83358..0000000
--- a/include/llvm/ADT/OwningPtr.h
+++ /dev/null
@@ -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
diff --git a/unittests/ADT/CMakeLists.txt b/unittests/ADT/CMakeLists.txt
index 5119723..0f214f3 100644
--- a/unittests/ADT/CMakeLists.txt
+++ b/unittests/ADT/CMakeLists.txt
@@ -23,7 +23,6 @@ set(ADTSources
MakeUniqueTest.cpp
MapVectorTest.cpp
OptionalTest.cpp
- OwningPtrTest.cpp
PackedVectorTest.cpp
PointerIntPairTest.cpp
PointerUnionTest.cpp
diff --git a/unittests/ADT/OwningPtrTest.cpp b/unittests/ADT/OwningPtrTest.cpp
deleted file mode 100644
index d83a947..0000000
--- a/unittests/ADT/OwningPtrTest.cpp
+++ /dev/null
@@ -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
-}
diff --git a/utils/llvm.natvis b/utils/llvm.natvis
index 9874ce5..6da0b25 100644
--- a/utils/llvm.natvis
+++ b/utils/llvm.natvis
@@ -108,14 +108,6 @@ or create a symbolic link so it updates automatically.
</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>
More information about the llvm-commits
mailing list