make Handle a synonym of Local

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 85 matching lines @@
 class StackFrame;
 class StackTrace;
 class String;
 class StringObject;
 class Symbol;
 class SymbolObject;
 class Private;
 class Uint32;
 class Utils;
 class Value;
-template <class T> class Handle;
 template <class T> class Local;
 template <class T> class Eternal;
 template<class T> class NonCopyablePersistentTraits;
 template<class T> class PersistentBase;
 template<class T,
          class M = NonCopyablePersistentTraits<T> > class Persistent;
 template<class T> class UniquePersistent;
 template<class K, class V, class T> class PersistentValueMap;
 template<class V, class T> class PersistentValueVector;
 template<class T, class P> class WeakCallbackObject;
@@ skipping 72 matching lines @@
  *
  * There are two types of handles: local and persistent handles.
  * Local handles are light-weight and transient and typically used in
  * local operations.  They are managed by HandleScopes.  Persistent
  * handles can be used when storing objects across several independent
  * operations and have to be explicitly deallocated when they're no
  * longer used.
  *
  * It is safe to extract the object stored in the handle by
  * dereferencing the handle (for instance, to extract the Object* from
- * a Handle<Object>); the value will still be governed by a handle
+ * a Local<Object>); the value will still be governed by a handle
  * behind the scenes and the same rules apply to these values as to
  * their handles.
  */
-template <class T> class Handle {
+template <class T>
+class Local {
  public:
-  /**
-   * Creates an empty handle.
-   */
-  V8_INLINE Handle() : val_(0) {}
-
-  /**
-   * Creates a handle for the contents of the specified handle.  This
-   * constructor allows you to pass handles as arguments by value and
-   * to assign between handles.  However, if you try to assign between
-   * incompatible handles, for instance from a Handle<String> to a
-   * Handle<Number> it will cause a compile-time error.  Assigning
-   * between compatible handles, for instance assigning a
-   * Handle<String> to a variable declared as Handle<Value>, is legal
-   * because String is a subclass of Value.
-   */
-  template <class S> V8_INLINE Handle(Handle<S> that)
+  V8_INLINE Local() : val_(0) {}
+  template <class S>
+  V8_INLINE Local(Local<S> that)
       : val_(reinterpret_cast<T*>(*that)) {

[Sven Panne, 2014/10/29 07:15:27]

Not really related to this CL: I think that we can remove this reinterpret_cast
and the TYPE_CHECK below (here and a few other places). This seems to be exactly
item 45 in "Effective C++" ("Use member function templates to accept all
compatible types"). Or did I miss something?

     /**
      * This check fails when trying to convert between incompatible
      * handles. For example, converting from a Handle<String> to a
      * Handle<Number>.
      */
     TYPE_CHECK(T, S);
   }
 
   /**
    * Returns true if the handle is empty.
    */
   V8_INLINE bool IsEmpty() const { return val_ == 0; }
 
   /**
    * Sets the handle to be empty. IsEmpty() will then return true.
    */
   V8_INLINE void Clear() { val_ = 0; }
 
   V8_INLINE T* operator->() const { return val_; }
 
   V8_INLINE T* operator*() const { return val_; }
 
   /**
    * Checks whether two handles are the same.
    * Returns true if both are empty, or if the objects
    * to which they refer are identical.
    * The handles' references are not checked.
    */
-  template <class S> V8_INLINE bool operator==(const Handle<S>& that) const {
+  template <class S>
+  V8_INLINE bool operator==(const Local<S>& that) const {
     internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
     internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
     if (a == 0) return b == 0;
     if (b == 0) return false;
     return *a == *b;
   }
 
   template <class S> V8_INLINE bool operator==(
       const PersistentBase<S>& that) const {
     internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
     internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
     if (a == 0) return b == 0;
     if (b == 0) return false;
     return *a == *b;
   }
 
   /**
    * Checks whether two handles are different.
    * Returns true if only one of the handles is empty, or if
    * the objects to which they refer are different.
    * The handles' references are not checked.
    */
-  template <class S> V8_INLINE bool operator!=(const Handle<S>& that) const {
+  template <class S>
+  V8_INLINE bool operator!=(const Local<S>& that) const {
     return !operator==(that);
   }
 
   template <class S> V8_INLINE bool operator!=(
       const Persistent<S>& that) const {
     return !operator==(that);
   }
 
-  template <class S> V8_INLINE static Handle<T> Cast(Handle<S> that) {
-#ifdef V8_ENABLE_CHECKS
-    // If we're going to perform the type check then we have to check
-    // that the handle isn't empty before doing the checked cast.
-    if (that.IsEmpty()) return Handle<T>();
-#endif
-    return Handle<T>(T::Cast(*that));
-  }
-
-  template <class S> V8_INLINE Handle<S> As() {
-    return Handle<S>::Cast(*this);
-  }
-
-  V8_INLINE static Handle<T> New(Isolate* isolate, Handle<T> that) {
-    return New(isolate, that.val_);
-  }
-  V8_INLINE static Handle<T> New(Isolate* isolate,
-                                 const PersistentBase<T>& that) {
-    return New(isolate, that.val_);
-  }
-
- private:
-  friend class Utils;
-  template<class F, class M> friend class Persistent;
-  template<class F> friend class PersistentBase;
-  template<class F> friend class Handle;
-  template<class F> friend class Local;
-  template<class F> friend class FunctionCallbackInfo;
-  template<class F> friend class PropertyCallbackInfo;
-  template<class F> friend class internal::CustomArguments;
-  friend Handle<Primitive> Undefined(Isolate* isolate);
-  friend Handle<Primitive> Null(Isolate* isolate);
-  friend Handle<Boolean> True(Isolate* isolate);
-  friend Handle<Boolean> False(Isolate* isolate);
-  friend class Context;
-  friend class HandleScope;
-  friend class Object;
-  friend class Private;
-
-  /**
-   * Creates a new handle for the specified value.
-   */
-  V8_INLINE explicit Handle(T* val) : val_(val) {}
-
-  V8_INLINE static Handle<T> New(Isolate* isolate, T* that);
-
-  T* val_;
-};
-
-
-/**
- * A light-weight stack-allocated object handle.  All operations
- * that return objects from within v8 return them in local handles.  They
- * are created within HandleScopes, and all local handles allocated within a
- * handle scope are destroyed when the handle scope is destroyed.  Hence it
- * is not necessary to explicitly deallocate local handles.
- */
-template <class T> class Local : public Handle<T> {
- public:
-  V8_INLINE Local();
-  template <class S> V8_INLINE Local(Local<S> that)
-      : Handle<T>(reinterpret_cast<T*>(*that)) {
-    /**
-     * This check fails when trying to convert between incompatible
-     * handles. For example, converting from a Handle<String> to a
-     * Handle<Number>.
-     */
-    TYPE_CHECK(T, S);
-  }
-
-
   template <class S> V8_INLINE static Local<T> Cast(Local<S> that) {
 #ifdef V8_ENABLE_CHECKS
     // If we're going to perform the type check then we have to check
     // that the handle isn't empty before doing the checked cast.
     if (that.IsEmpty()) return Local<T>();
 #endif
     return Local<T>(T::Cast(*that));
   }
-  template <class S> V8_INLINE Local(Handle<S> that)
-      : Handle<T>(reinterpret_cast<T*>(*that)) {
-    TYPE_CHECK(T, S);
-  }
+
 
   template <class S> V8_INLINE Local<S> As() {
     return Local<S>::Cast(*this);
   }
 
   /**
    * Create a local handle for the content of another handle.
    * The referee is kept alive by the local handle even when
    * the original handle is destroyed/disposed.
    */
-  V8_INLINE static Local<T> New(Isolate* isolate, Handle<T> that);
+  V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that);
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const PersistentBase<T>& that);
 
  private:
   friend class Utils;
   template<class F> friend class Eternal;
   template<class F> friend class PersistentBase;
   template<class F, class M> friend class Persistent;
-  template<class F> friend class Handle;
   template<class F> friend class Local;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
   friend class String;
   friend class Object;
   friend class Context;
+  friend class Private;
   template<class F> friend class internal::CustomArguments;
+  friend Local<Primitive> Undefined(Isolate* isolate);
+  friend Local<Primitive> Null(Isolate* isolate);
+  friend Local<Boolean> True(Isolate* isolate);
+  friend Local<Boolean> False(Isolate* isolate);
   friend class HandleScope;
   friend class EscapableHandleScope;
   template<class F1, class F2, class F3> friend class PersistentValueMap;
   template<class F1, class F2> friend class PersistentValueVector;
 
-  template <class S> V8_INLINE Local(S* that) : Handle<T>(that) { }
+  template <class S>
+  V8_INLINE Local(S* that)
+      : val_(that) {}
   V8_INLINE static Local<T> New(Isolate* isolate, T* that);
+
+  T* val_;
 };
 
 
+// Handle is a synonym for Local for historical reason.
+template <class T>
+using Handle = Local<T>;
+
+
 // Eternal handles are set-once handles that live for the life of the isolate.
 template <class T> class Eternal {
  public:
   V8_INLINE Eternal() : index_(kInitialValue) { }
   template<class S>
   V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : index_(kInitialValue) {
     Set(isolate, handle);
   }
   // Can only be safely called if already set.
   V8_INLINE Local<T> Get(Isolate* isolate);
@@ skipping 144 matching lines @@
 
   /**
    * Returns the class ID previously assigned to this handle or 0 if no class ID
    * was previously assigned.
    */
   V8_INLINE uint16_t WrapperClassId() const;
 
  private:
   friend class Isolate;
   friend class Utils;
-  template<class F> friend class Handle;
   template<class F> friend class Local;
   template<class F1, class F2> friend class Persistent;
   template<class F> friend class UniquePersistent;
   template<class F> friend class PersistentBase;
   template<class F> friend class ReturnValue;
   template<class F1, class F2, class F3> friend class PersistentValueMap;
   template<class F1, class F2> friend class PersistentValueVector;
   friend class Object;
 
   explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
@@ skipping 120 matching lines @@
   }
 
   // TODO(dcarney): this is pretty useless, fix or remove
   template <class S> V8_INLINE Persistent<S>& As() { // NOLINT
     return Persistent<S>::Cast(*this);
   }
 
  private:
   friend class Isolate;
   friend class Utils;
-  template<class F> friend class Handle;
   template<class F> friend class Local;
   template<class F1, class F2> friend class Persistent;
   template<class F> friend class ReturnValue;
 
   template <class S> V8_INLINE Persistent(S* that) : PersistentBase<T>(that) { }
   V8_INLINE T* operator*() const { return this->val_; }
   template<class S, class M2>
   V8_INLINE void Copy(const Persistent<S, M2>& that);
 };
 
@@ skipping 4619 matching lines @@
   typedef WeakCallbackData<Value, void>::Callback WeakCallback;
   static void MakeWeak(internal::Object** global_handle,
                        void* data,
                        WeakCallback weak_callback);
   static void* ClearWeak(internal::Object** global_handle);
   static void Eternalize(Isolate* isolate,
                          Value* handle,
                          int* index);
   static Local<Value> GetEternal(Isolate* isolate, int index);
 
-  template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Eternal;
   template <class T> friend class PersistentBase;
   template <class T, class M> friend class Persistent;
   friend class Context;
 };
 
 
 /**
  * An external exception handler.
@@ skipping 701 matching lines @@
     int value_offset =
         I::kFixedArrayHeaderSize + (internal::kApiPointerSize * index);
     return I::ReadField<T>(embedder_data, value_offset);
   }
 };
 
 }  // namespace internal
 
 
 template <class T>
-Local<T>::Local() : Handle<T>() { }
-
-
-template <class T>
-Local<T> Local<T>::New(Isolate* isolate, Handle<T> that) {
+Local<T> Local<T>::New(Isolate* isolate, Local<T> that) {
   return New(isolate, that.val_);
 }
 
 template <class T>
 Local<T> Local<T>::New(Isolate* isolate, const PersistentBase<T>& that) {
   return New(isolate, that.val_);
 }
 
-template <class T>
-Handle<T> Handle<T>::New(Isolate* isolate, T* that) {
-  if (that == NULL) return Handle<T>();
-  T* that_ptr = that;
-  internal::Object** p = reinterpret_cast<internal::Object**>(that_ptr);
-  return Handle<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
-      reinterpret_cast<internal::Isolate*>(isolate), *p)));
-}
-
 
 template <class T>
 Local<T> Local<T>::New(Isolate* isolate, T* that) {
   if (that == NULL) return Local<T>();
   T* that_ptr = that;
   internal::Object** p = reinterpret_cast<internal::Object**>(that_ptr);
   return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
       reinterpret_cast<internal::Isolate*>(isolate), *p)));
 }
 
@@ skipping 987 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_