JSSpecCompiler: Pave a way for representing compile-time objects

Author: https://github.com/DanShaders
Commit: d99d66e358
Pull-request: https://github.com/SerenityOS/serenity/pull/23647
Reviewed-by: https://github.com/ADKaster ✅

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/Runtime/Object.h

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2024, Dan Klishch <danilklishch@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/TypeCasts.h>
+
+#include "DiagnosticEngine.h"
+#include "Function.h"
+#include "Runtime/ObjectType.h"
+
+namespace JSSpecCompiler::Runtime {
+
+struct Slot {
+    bool operator==(Slot const&) const = default;
+
+    FlyString key;
+};
+
+struct StringPropertyKey {
+    bool operator==(StringPropertyKey const&) const = default;
+
+    FlyString key;
+};
+
+#define ENUMERATE_WELL_KNOWN_SYMBOLS(F) \
+    F(InstanceType, _instanceType)      \
+    F(ToStringTag, toStringTag)
+
+enum class WellKnownSymbol {
+#define ID(enum_name, spec_name) enum_name,
+    ENUMERATE_WELL_KNOWN_SYMBOLS(ID)
+#undef ID
+};
+
+class PropertyKey : public Variant<Slot, StringPropertyKey, WellKnownSymbol> {
+public:
+    using Variant::Variant;
+};
+
+struct DataProperty {
+    template<typename T>
+    bool is() const
+    {
+        return ::is<Runtime::Object>(value);
+    }
+
+    template<typename T>
+    T* as() const
+    {
+        return verify_cast<T>(value);
+    }
+
+    template<typename T>
+    Optional<T*> get_or_diagnose(Realm* realm, QualifiedName name, Location location)
+    {
+        if (!is<T>()) {
+            realm->diag().error(location,
+                "{} must be a {}", name.to_string(), T::TYPE_NAME);
+            realm->diag().note(this->location,
+                "set to {} here", value->type_name());
+            return {};
+        }
+        return verify_cast<T>(value);
+    }
+
+    Cell* value;
+    Location location;
+
+    bool is_writable = true;
+    bool is_enumerable = false;
+    bool is_configurable = true;
+};
+
+struct AccessorProperty {
+    Optional<FunctionDeclarationRef> getter;
+    Optional<FunctionDeclarationRef> setter;
+    Location location;
+
+    bool is_enumerable = false;
+    bool is_configurable = true;
+};
+
+class Property : public Variant<DataProperty, AccessorProperty> {
+public:
+    using Variant::Variant;
+
+    Location location() const
+    {
+        return visit([&](auto const& value) { return value.location; });
+    }
+
+    Optional<DataProperty&> get_data_property_or_diagnose(Realm* realm, QualifiedName name, Location location);
+};
+
+class Object : public Runtime::Cell {
+public:
+    static constexpr StringView TYPE_NAME = "object"sv;
+
+    static Object* create(Realm* realm)
+    {
+        return realm->adopt_cell(new Object {});
+    }
+
+    StringView type_name() const override { return TYPE_NAME; }
+
+    auto& type() { return m_type; }
+    auto& properties() { return m_properties; }
+
+    bool has(PropertyKey const& key) const
+    {
+        return m_properties.contains(key);
+    }
+
+    Property& get(PropertyKey const& key)
+    {
+        return m_properties.get(key).value();
+    }
+
+    void set(PropertyKey const& key, Property&& property)
+    {
+        auto insertion_result = m_properties.set(key, move(property));
+        VERIFY(insertion_result == HashSetResult::InsertedNewEntry);
+    }
+
+protected:
+    void do_dump(Printer& printer) const override;
+
+private:
+    Object() = default;
+
+    Optional<ObjectType*> m_type;
+    HashMap<PropertyKey, Property> m_properties;
+};
+
+}
+
+template<>
+struct AK::Traits<JSSpecCompiler::Runtime::PropertyKey> : public DefaultTraits<JSSpecCompiler::Runtime::PropertyKey> {
+    static unsigned hash(JSSpecCompiler::Runtime::PropertyKey const& key)
+    {
+        using namespace JSSpecCompiler::Runtime;
+        return key.visit(
+            [](Slot const& slot) { return pair_int_hash(1, slot.key.hash()); },
+            [](StringPropertyKey const& string_key) { return pair_int_hash(2, string_key.key.hash()); },
+            [](WellKnownSymbol const& symbol) { return pair_int_hash(3, to_underlying(symbol)); });
+    }
+};