Version 3.5.6.

include/v8.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 153 matching lines @@
  * dereferencing the handle (for instance, to extract the Object* from
  * a Handle<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 {
  public:
   /**
    * Creates an empty handle.
    */
-  inline Handle();
+  inline Handle() : val_(0) {}
 
   /**
    * Creates a new handle for the specified value.
    */
-  inline explicit Handle(T* val) : val_(val) { }
+  inline explicit Handle(T* val) : val_(val) {}
 
   /**
    * 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> inline Handle(Handle<S> that)
       : val_(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);
   }
 
   /**
    * Returns true if the handle is empty.
    */
   inline bool IsEmpty() const { return val_ == 0; }
 
+  /**
+   * Sets the handle to be empty. IsEmpty() will then return true.
+   */
+  inline void Clear() { val_ = 0; }
+
   inline T* operator->() const { return val_; }
 
   inline T* operator*() const { return val_; }
 
   /**
-   * Sets the handle to be empty. IsEmpty() will then return true.
-   */
-  inline void Clear() { this->val_ = 0; }
-
-  /**
    * 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> inline bool operator==(Handle<S> that) const {
     internal::Object** a = reinterpret_cast<internal::Object**>(**this);
     internal::Object** b = reinterpret_cast<internal::Object**>(*that);
     if (a == 0) return b == 0;
     if (b == 0) return false;
@@ skipping 3594 matching lines @@
   static inline bool CanCastToHeapObject(Object* o) { return true; }
   static inline bool CanCastToHeapObject(Message* o) { return true; }
   static inline bool CanCastToHeapObject(StackTrace* o) { return true; }
   static inline bool CanCastToHeapObject(StackFrame* o) { return true; }
 };
 
 }  // namespace internal
 
 
 template <class T>
-Handle<T>::Handle() : val_(0) { }
-
-
-template <class T>
 Local<T>::Local() : Handle<T>() { }
 
 
 template <class T>
 Local<T> Local<T>::New(Handle<T> that) {
   if (that.IsEmpty()) return Local<T>();
   T* that_ptr = *that;
   internal::Object** p = reinterpret_cast<internal::Object**>(that_ptr);
   if (internal::Internals::CanCastToHeapObject(that_ptr)) {
     return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
@@ skipping 357 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_