LibJS: Move Handle's Value specialization to Value header

This is part of an effort to keep JS runtime specifics outside of the
Heap implementation.

Libraries/LibJS/Bytecode/Executable.cpp

@@ -5,6 +5,7 @@
  */
 
 #include <LibJS/Bytecode/BasicBlock.h>
+#include <LibJS/Runtime/Value.h>
 #include <LibJS/Bytecode/Executable.h>
 #include <LibJS/Bytecode/Instruction.h>
 #include <LibJS/Bytecode/RegexTable.h>

Libraries/LibJS/Heap/Handle.h

@@ -13,7 +13,7 @@
 #include <AK/RefPtr.h>
 #include <AK/SourceLocation.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Runtime/Value.h>
+#include <LibJS/Heap/GCPtr.h>
 
 namespace JS {
 
@@ -149,47 +149,6 @@ inline Handle<T> make_handle(NonnullGCPtr<T> cell, SourceLocation location = Sou
     return Handle<T>::create(cell.ptr(), location);
 }
 
-template<>
-class Handle<Value> {
-public:
-    Handle() = default;
-
-    static Handle create(Value value, SourceLocation location)
-    {
-        if (value.is_cell())
-            return Handle(value, &value.as_cell(), location);
-        return Handle(value);
-    }
-
-    auto cell() { return m_handle.cell(); }
-    auto cell() const { return m_handle.cell(); }
-    auto value() const { return *m_value; }
-    bool is_null() const { return m_handle.is_null() && !m_value.has_value(); }
-
-    bool operator==(Value const& value) const { return value == m_value; }
-    bool operator==(Handle<Value> const& other) const { return other.m_value == this->m_value; }
-
-private:
-    explicit Handle(Value value)
-        : m_value(value)
-    {
-    }
-
-    explicit Handle(Value value, Cell* cell, SourceLocation location)
-        : m_value(value)
-        , m_handle(Handle<Cell>::create(cell, location))
-    {
-    }
-
-    Optional<Value> m_value;
-    Handle<Cell> m_handle;
-};
-
-inline Handle<Value> make_handle(Value value, SourceLocation location = SourceLocation::current())
-{
-    return Handle<Value>::create(value, location);
-}
-
 }
 
 namespace AK {
@@ -199,11 +158,6 @@ struct Traits<JS::Handle<T>> : public DefaultTraits<JS::Handle<T>> {
     static unsigned hash(JS::Handle<T> const& handle) { return Traits<T>::hash(handle); }
 };
 
-template<>
-struct Traits<JS::Handle<JS::Value>> : public DefaultTraits<JS::Handle<JS::Value>> {
-    static unsigned hash(JS::Handle<JS::Value> const& handle) { return Traits<JS::Value>::hash(handle.value()); }
-};
-
 namespace Detail {
 template<typename T>
 inline constexpr bool IsHashCompatible<JS::Handle<T>, T> = true;

Libraries/LibJS/Runtime/Value.h

@@ -15,10 +15,12 @@
 #include <AK/Forward.h>
 #include <AK/Function.h>
 #include <AK/Result.h>
+#include <AK/SourceLocation.h>
 #include <AK/String.h>
 #include <AK/Types.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/GCPtr.h>
+#include <LibJS/Heap/Handle.h>
 #include <math.h>
 
 namespace JS {
@@ -725,6 +727,55 @@ private:
     JS::Value m_value;
 };
 
+}
+
+namespace JS {
+
+template<>
+class Handle<Value> {
+public:
+    Handle() = default;
+
+    static Handle create(Value value, SourceLocation location)
+    {
+        if (value.is_cell())
+            return Handle(value, &value.as_cell(), location);
+        return Handle(value);
+    }
+
+    auto cell() { return m_handle.cell(); }
+    auto cell() const { return m_handle.cell(); }
+    auto value() const { return *m_value; }
+    bool is_null() const { return m_handle.is_null() && !m_value.has_value(); }
+
+    bool operator==(Value const& value) const { return value == m_value; }
+    bool operator==(Handle<Value> const& other) const { return other.m_value == this->m_value; }
+
+private:
+    explicit Handle(Value value)
+        : m_value(value)
+    {
+    }
+
+    explicit Handle(Value value, Cell* cell, SourceLocation location)
+        : m_value(value)
+        , m_handle(Handle<Cell>::create(cell, location))
+    {
+    }
+
+    Optional<Value> m_value;
+    Handle<Cell> m_handle;
+};
+
+inline Handle<Value> make_handle(Value value, SourceLocation location = SourceLocation::current())
+{
+    return Handle<Value>::create(value, location);
+}
+
+}
+
+namespace AK {
+
 template<>
 struct Formatter<JS::Value> : Formatter<StringView> {
     ErrorOr<void> format(FormatBuilder& builder, JS::Value value)
@@ -741,4 +792,9 @@ struct Traits<JS::Value> : DefaultTraits<JS::Value> {
     static constexpr bool is_trivial() { return true; }
 };
 
+template<>
+struct Traits<JS::Handle<JS::Value>> : public DefaultTraits<JS::Handle<JS::Value>> {
+    static unsigned hash(JS::Handle<JS::Value> const& handle) { return Traits<JS::Value>::hash(handle.value()); }
+};
+
 }