give UniquePersistent full move semantics

include/v8.h

Index: include/v8.h
diff --git a/include/v8.h b/include/v8.h
index 69a9c9c8247d1919d55fba58f39d8c0a35a8bf4e..84ef170de0e4773e71c48f2df345e993b637ca83 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -665,8 +665,8 @@ template <class T> class PersistentBase {
   friend class Object;
 
   explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
-  PersistentBase(PersistentBase& other); // NOLINT
-  void operator=(PersistentBase&);
+  PersistentBase(PersistentBase& other) = delete;  // NOLINT
+  void operator=(PersistentBase&) = delete;
   V8_INLINE static T* New(Isolate* isolate, T* that);
 
   T* val_;
@@ -814,16 +814,11 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
  */
 template<class T>
 class UniquePersistent : public PersistentBase<T> {
-  struct RValue {
-    V8_INLINE explicit RValue(UniquePersistent* obj) : object(obj) {}
-    UniquePersistent* object;
-  };
-
  public:
   /**
    * A UniquePersistent with no storage cell.
    */
-  V8_INLINE UniquePersistent() : PersistentBase<T>(0) { }
+  V8_INLINE UniquePersistent() : PersistentBase<T>(nullptr) {}
   /**
    * Construct a UniquePersistent from a Handle.
    * When the Handle is non-empty, a new storage cell is created
@@ -847,34 +842,31 @@ class UniquePersistent : public PersistentBase<T> {
   /**
    * Move constructor.
    */
-  V8_INLINE UniquePersistent(RValue rvalue)
-    : PersistentBase<T>(rvalue.object->val_) {
-    rvalue.object->val_ = 0;
+  V8_INLINE UniquePersistent(UniquePersistent&& other)
+      : PersistentBase<T>(other.val_) {
+    other.val_ = nullptr;
   }
   V8_INLINE ~UniquePersistent() { this->Reset(); }
   /**
    * Move via assignment.
    */
-  template<class S>
-  V8_INLINE UniquePersistent& operator=(UniquePersistent<S> rhs) {
+  template <class S>
+  V8_INLINE UniquePersistent& operator=(UniquePersistent<S>&& rhs) {

[jamesr, 2015/03/04 18:52:37]

operator=(T&&)s should support self assignment, but this appears to blow away
the object if |*this| == |rhs|. a safer way to write this would be

if (this != &rhs) {
  TYPE_CHECK
  ..
}

return *this

[dcarney, 2015/03/04 19:40:24]

good catch, thanks

     TYPE_CHECK(T, S);
     this->Reset();
     this->val_ = rhs.val_;
-    rhs.val_ = 0;
+    rhs.val_ = nullptr;
     return *this;
   }
   /**
-   * Cast operator for moves.
-   */
-  V8_INLINE operator RValue() { return RValue(this); }
-  /**
    * Pass allows returning uniques from functions, etc.
    */
-  UniquePersistent Pass() { return UniquePersistent(RValue(this)); }
+  // TODO(dcarney): deprecate, this is just std::move
+  UniquePersistent Pass() { return static_cast<UniquePersistent&&>(*this); }
 
  private:
-  UniquePersistent(UniquePersistent&);
-  void operator=(UniquePersistent&);
+  UniquePersistent(UniquePersistent&) = delete;
+  void operator=(UniquePersistent&) = delete;
 };