[Interpreter] Add CreateClosure to BytecodeGraphBuilder.

src/handles.h

 // Copyright 2011 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.
 
 #ifndef V8_HANDLES_H_
 #define V8_HANDLES_H_
 
 #include "include/v8.h"
 #include "src/base/functional.h"
 #include "src/base/macros.h"
@@ skipping 58 matching lines @@
 };
 
 
 // ----------------------------------------------------------------------------
 // A Handle provides a reference to an object that survives relocation by
 // the garbage collector.
 //
 // Handles are only valid within a HandleScope. When a handle is created
 // for an object a cell is allocated in the current HandleScope.
 //
 // Also note that Handles do not provide default equality comparison or hashing

[Michael Starzinger, 2015/11/20 17:11:43]

Please appreciate this comment and remove the equality operator. :)

[oth, 2015/11/21 14:19:47]

Yes! This wasn't intended to be part of the CL. I was attempting to understand
why compilation was failing with MSVC, but without direct access to a machine.

 // operators on purpose. Such operators would be misleading, because intended
 // semantics is ambiguous between Handle location and object identity. Instead
 // use either {is_identical_to} or {location} explicitly.
 template <typename T>
 class Handle final : public HandleBase {
  public:
   V8_INLINE explicit Handle(T** location = nullptr)
       : HandleBase(reinterpret_cast<Object**>(location)) {
     Object* a = nullptr;
     T* b = nullptr;
@@ skipping 17 matching lines @@
     USE(a);
   }
 
   V8_INLINE T* operator->() const { return operator*(); }
 
   // Provides the C++ dereference operator.
   V8_INLINE T* operator*() const {
     return reinterpret_cast<T*>(HandleBase::operator*());
   }
 
+  V8_INLINE bool operator==(const Handle<T>& other) {
+    return is_identical_to(other);
+  }
+
   // Returns the address to where the raw pointer is stored.
   V8_INLINE T** location() const {
     return reinterpret_cast<T**>(HandleBase::location());
   }
 
   template <typename S>
   static const Handle<T> cast(Handle<S> that) {
     T::cast(*reinterpret_cast<T**>(that.location_));
     return Handle<T>(reinterpret_cast<T**>(that.location_));
   }
@@ skipping 272 matching lines @@
     next = limit = NULL;
     sealed_level = level = 0;
     canonical_scope = NULL;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HANDLES_H_