@ugo-studio/jspp 0.3.0 → 0.3.1

package/src/prelude/any_value.cpp

@@ -0,0 +1,636 @@
+#include "jspp.hpp"
+#include "any_value.hpp"
+#include "values/iterator.hpp"
+#include "values/async_iterator.hpp"
+#include "values/string.hpp"
+#include "values/object.hpp"
+#include "values/array.hpp"
+#include "values/function.hpp"
+#include "values/promise.hpp"
+#include "values/symbol.hpp"
+#include "values/descriptors.hpp"
+#include "exception.hpp"
+
+namespace jspp {
+
+// --- AnyValue methods that were in any_value_helpers.hpp ---
+
+bool AnyValue::operator==(const AnyValue &other) const noexcept {
+    return storage == other.storage;
+}
+bool AnyValue::operator==(const std::string &other) const noexcept {
+    if (!is_string())
+        return false;
+    return as_string()->value == other;
+}
+bool AnyValue::operator<(const AnyValue &other) const noexcept {
+    return storage < other.storage;
+}
+
+JsString *AnyValue::as_string() const noexcept { return static_cast<JsString *>(get_ptr()); }
+JsObject *AnyValue::as_object() const noexcept { return static_cast<JsObject *>(get_ptr()); }
+JsArray *AnyValue::as_array() const noexcept { return static_cast<JsArray *>(get_ptr()); }
+JsFunction *AnyValue::as_function() const noexcept { return static_cast<JsFunction *>(get_ptr()); }
+JsSymbol *AnyValue::as_symbol() const noexcept { return static_cast<JsSymbol *>(get_ptr()); }
+JsPromise *AnyValue::as_promise() const noexcept { return static_cast<JsPromise *>(get_ptr()); }
+DataDescriptor *AnyValue::as_data_descriptor() const noexcept { return static_cast<DataDescriptor *>(get_ptr()); }
+AccessorDescriptor *AnyValue::as_accessor_descriptor() const noexcept { return static_cast<AccessorDescriptor *>(get_ptr()); }
+
+bool AnyValue::is_generator() const noexcept { return is_function() && as_function()->is_generator; }
+
+// --- AnyValue FACTORIES ---
+AnyValue AnyValue::make_string(const std::string &raw_s) noexcept
+{
+    return from_ptr(new JsString(raw_s));
+}
+AnyValue AnyValue::make_object(std::initializer_list<std::pair<std::string, AnyValue>> props) noexcept
+{
+    return from_ptr(new JsObject(props, make_null()));
+}
+AnyValue AnyValue::make_object(const std::map<std::string, AnyValue> &props) noexcept
+{
+    return from_ptr(new JsObject(props, make_null()));
+}
+AnyValue AnyValue::make_array(std::span<const AnyValue> dense) noexcept
+{
+    std::vector<AnyValue> vec;
+    vec.reserve(dense.size());
+    for (const auto &item : dense)
+        vec.push_back(item);
+    return from_ptr(new JsArray(std::move(vec)));
+}
+AnyValue AnyValue::make_array(const std::vector<AnyValue> &dense) noexcept
+{
+    return from_ptr(new JsArray(dense));
+}
+AnyValue AnyValue::make_array(std::vector<AnyValue> &&dense) noexcept
+{
+    return from_ptr(new JsArray(std::move(dense)));
+}
+AnyValue AnyValue::make_function(const JsFunctionCallable &call, const std::optional<std::string> &name, bool is_constructor) noexcept
+{
+    auto v = from_ptr(new JsFunction(call, name, {}, {}, false, is_constructor));
+    auto proto = make_object({});
+    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+    return v;
+}
+AnyValue AnyValue::make_class(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+{
+    auto v = from_ptr(new JsFunction(call, name, {}, {}, true));
+    auto proto = make_object({});
+    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+    return v;
+}
+AnyValue AnyValue::make_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+{
+    auto v = from_ptr(new JsFunction(call, true, name, {}, {}, false));
+    auto proto = make_object({});
+    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+    return v;
+}
+AnyValue AnyValue::make_async_function(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+{
+    auto v = from_ptr(new JsFunction(call, false, true, name, {}, {}, false));
+    auto proto = make_object({});
+    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+    return v;
+}
+AnyValue AnyValue::make_async_generator(const JsFunctionCallable &call, const std::optional<std::string> &name) noexcept
+{
+    auto v = from_ptr(new JsFunction(call, true, true, name, {}, {}, false));
+    auto proto = make_object({});
+    proto.define_data_property("constructor", AnyValue::make_data_descriptor(v, true, false, false));
+    v.define_data_property("prototype", AnyValue::make_data_descriptor(proto, false, false, false));
+    return v;
+}
+AnyValue AnyValue::make_symbol(const std::string &description) noexcept
+{
+    return from_ptr(new JsSymbol(description));
+}
+AnyValue AnyValue::make_promise(const JsPromise &promise) noexcept
+{
+    auto p = new JsPromise();
+    *p = promise;
+    return from_ptr(p);
+}
+AnyValue AnyValue::make_data_descriptor(AnyValue value, bool writable, bool enumerable, bool configurable) noexcept
+{
+    return from_ptr(new DataDescriptor(value, writable, enumerable, configurable));
+}
+AnyValue AnyValue::make_accessor_descriptor(const std::optional<std::function<AnyValue(AnyValue, std::span<const AnyValue>)>> &get,
+                                                   const std::optional<std::function<AnyValue(AnyValue, std::span<const AnyValue>)>> &set,
+                                                   bool enumerable,
+                                                   bool configurable) noexcept
+{
+    return from_ptr(new AccessorDescriptor(get, set, enumerable, configurable));
+}
+
+AnyValue AnyValue::from_symbol(JsSymbol *sym) noexcept {
+    return from_ptr(sym);
+}
+AnyValue AnyValue::from_string(JsString *str) noexcept {
+    return from_ptr(str);
+}
+AnyValue AnyValue::from_promise(JsPromise &&promise) noexcept {
+    auto it = new JsPromise(std::move(promise));
+    return from_ptr(it);
+}
+AnyValue AnyValue::from_iterator(JsIterator<AnyValue> &&iterator) noexcept {
+    auto it = new JsIterator<AnyValue>(std::move(iterator));
+    return from_ptr(it);
+}
+AnyValue AnyValue::from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept {
+    return from_ptr(iterator);
+}
+AnyValue AnyValue::from_async_iterator(JsAsyncIterator<AnyValue> &&iterator) noexcept {
+    auto it = new JsAsyncIterator<AnyValue>(std::move(iterator));
+    return from_ptr(it);
+}
+
+AnyValue AnyValue::resolve_property_for_read(const AnyValue &val, AnyValue thisVal, const std::string &propName) noexcept {
+    if (val.is_data_descriptor()) {
+        return val.as_data_descriptor()->value;
+    }
+    if (val.is_accessor_descriptor()) {
+        auto accessor = val.as_accessor_descriptor();
+        if (accessor->get.has_value())
+            return accessor->get.value()(thisVal, std::span<const AnyValue>{});
+        else {
+            return Constants::UNDEFINED;
+        }
+    }
+    return val;
+}
+
+AnyValue AnyValue::resolve_property_for_write(AnyValue &val, AnyValue thisVal, const AnyValue &new_val, const std::string &propName) {
+    if (val.is_data_descriptor()) {
+        auto data = val.as_data_descriptor();
+        if (data->writable) {
+            data->value = new_val;
+            return new_val;
+        } else {
+            throw Exception::make_exception("Cannot assign to read only property '" + propName + "' of object '#<Object>'", "TypeError");
+        }
+    }
+    if (val.is_accessor_descriptor()) {
+        auto accessor = val.as_accessor_descriptor();
+        if (accessor->set.has_value()) {
+            const AnyValue args[] = {new_val};
+            accessor->set.value()(thisVal, std::span<const AnyValue>(args, 1));
+            return new_val;
+        } else {
+            throw Exception::make_exception("Cannot set property of #<Object> which has only a getter", "TypeError");
+        }
+    }
+    val = new_val;
+    return new_val;
+}
+
+std::string AnyValue::to_std_string() const {
+    switch (get_type()) {
+    case JsType::Undefined: return "undefined";
+    case JsType::Null: return "null";
+    case JsType::Boolean: return as_boolean() ? "true" : "false";
+    case JsType::String: return as_string()->to_std_string();
+    case JsType::Object: return as_object()->to_std_string();
+    case JsType::Array: return as_array()->to_std_string();
+    case JsType::Function: return as_function()->to_std_string();
+    case JsType::Iterator: return as_iterator()->to_std_string();
+    case JsType::AsyncIterator: return as_async_iterator()->to_std_string();
+    case JsType::Promise: return as_promise()->to_std_string();
+    case JsType::Symbol: return as_symbol()->to_std_string();
+    case JsType::DataDescriptor: return as_data_descriptor()->value.to_std_string();
+    case JsType::AccessorDescriptor: {
+        if (as_accessor_descriptor()->get.has_value())
+            return as_accessor_descriptor()->get.value()(*this, {}).to_std_string();
+        else
+            return "undefined";
+    }
+    case JsType::Number: {
+        double num = as_double();
+        if (std::isnan(num)) return "NaN";
+        if (std::abs(num) >= 1e21 || (std::abs(num) > 0 && std::abs(num) < 1e-6)) {
+            std::ostringstream oss;
+            oss << std::scientific << std::setprecision(4) << num;
+            return oss.str();
+        } else {
+            std::ostringstream oss;
+            oss << std::setprecision(6) << std::fixed << num;
+            std::string s = oss.str();
+            s.erase(s.find_last_not_of('0') + 1, std::string::npos);
+            if (!s.empty() && s.back() == '.') s.pop_back();
+            return s;
+        }
+    }
+    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>");
+    default: return "";
+    }
+}
+
+std::string AnyValue::to_property_key() const {
+    if (is_symbol()) return as_symbol()->key;
+    return to_std_string();
+}
+
+AnyValue &AnyValue::set_prototype(AnyValue proto) {
+    if (is_object()) as_object()->proto = proto;
+    else if (is_array()) as_array()->proto = proto;
+    else if (is_function()) as_function()->proto = proto;
+    else if (is_uninitialized()) Exception::throw_uninitialized_reference("#<Object>");
+    return *this;
+}
+
+AnyValue AnyValue::call(AnyValue thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const {
+    if (!is_function())
+        throw Exception::make_exception(expr.value_or(to_std_string()) + " is not a function", "TypeError");
+    return as_function()->call(thisVal, args);
+}
+AnyValue AnyValue::optional_call(AnyValue thisVal, std::span<const AnyValue> args, const std::optional<std::string> &expr) const {
+    if (is_null() || is_undefined()) return Constants::UNDEFINED;
+    return as_function()->call(thisVal, args);
+}
+
+AnyValue AnyValue::construct(std::span<const AnyValue> args, const std::optional<std::string> &name) const {
+    if (!is_function() || !as_function()->is_constructor) {
+        throw Exception::make_exception(name.value_or(to_std_string()) + " is not a constructor", "TypeError");
+    }
+    AnyValue proto = get_own_property("prototype");
+    if (!proto.is_object()) proto = AnyValue::make_object({});
+    AnyValue instance = AnyValue::make_object({}).set_prototype(proto);
+    AnyValue result = call(instance, args);
+    if (result.is_object() || result.is_function() || result.is_array() || result.is_promise()) return result;
+    return instance;
+}
+
+// --- AnyValue methods that were in any_value_access.hpp ---
+
+AnyValue AnyValue::get_own_property(const std::string &key) const {
+    return get_property_with_receiver(key, *this);
+}
+
+AnyValue AnyValue::get_own_property_descriptor(const AnyValue &key) const {
+    if (key.is_symbol()) {
+        switch (get_type()) {
+        case JsType::Object: {
+            auto obj = as_object();
+            auto it = obj->symbol_props.find(key);
+            if (it != obj->symbol_props.end()) return it->second;
+            return Constants::UNDEFINED;
+        }
+        case JsType::Array: {
+            auto arr = as_array();
+            auto it = arr->symbol_props.find(key);
+            if (it != arr->symbol_props.end()) return it->second;
+            return Constants::UNDEFINED;
+        }
+        case JsType::Function: {
+            auto func = as_function();
+            auto it = func->symbol_props.find(key);
+            if (it != func->symbol_props.end()) return it->second;
+            return Constants::UNDEFINED;
+        }
+        default: return Constants::UNDEFINED;
+        }
+    }
+
+    std::string key_str = key.to_std_string();
+    switch (get_type()) {
+    case JsType::Object: {
+        auto obj = as_object();
+        if (obj->deleted_keys.count(key_str)) return Constants::UNDEFINED;
+        auto offset = obj->shape->get_offset(key_str);
+        if (offset.has_value()) return obj->storage[offset.value()];
+        return Constants::UNDEFINED;
+    }
+    case JsType::Array: {
+        auto arr = as_array();
+        if (key_str == "length") return AnyValue::make_number(arr->length);
+        if (JsArray::is_array_index(key_str)) {
+            uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+            if (idx < arr->dense.size() && !arr->dense[idx].is_uninitialized()) return arr->dense[idx];
+            if (arr->sparse.count(idx)) return arr->sparse[idx];
+        }
+        if (arr->props.count(key_str)) return arr->props.at(key_str);
+        return Constants::UNDEFINED;
+    }
+    case JsType::Function: {
+        auto func = as_function();
+        if (func->props.count(key_str)) return func->props.at(key_str);
+        return Constants::UNDEFINED;
+    }
+    case JsType::String: {
+        auto str = as_string();
+        if (key_str == "length") return AnyValue::make_number(str->value.length());
+        if (JsArray::is_array_index(key_str)) {
+            uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+            if (idx < str->value.length()) return AnyValue::make_string(std::string(1, str->value[idx]));
+        }
+        return Constants::UNDEFINED;
+    }
+    default: return Constants::UNDEFINED;
+    }
+}
+
+bool AnyValue::has_property(const std::string &key) const {
+    switch (get_type()) {
+    case JsType::Object: return as_object()->has_property(key);
+    case JsType::Array: return as_array()->has_property(key);
+    case JsType::Function: return as_function()->has_property(key);
+    case JsType::Promise: return as_promise()->get_property(key, *this).is_undefined() == false;
+    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_property(key, *this).is_undefined() == false;
+    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_property(key, *this).is_undefined() == false;
+    case JsType::Symbol: return SymbolPrototypes::get(key).has_value();
+    case JsType::String:
+        if (key == "length") return true;
+        if (JsArray::is_array_index(key)) {
+            uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+            return idx < as_string()->value.length();
+        }
+        return StringPrototypes::get(key).has_value();
+    case JsType::Number: return NumberPrototypes::get(key).has_value();
+    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>"); return false;
+    default: return false;
+    }
+}
+
+bool AnyValue::has_property(const AnyValue &key) const {
+    if (key.is_symbol()) {
+        switch (get_type()) {
+        case JsType::Object: return as_object()->has_symbol_property(key);
+        case JsType::Array: return as_array()->has_symbol_property(key);
+        case JsType::Function: return as_function()->has_symbol_property(key);
+        case JsType::Promise: return as_promise()->has_symbol_property(key);
+        case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->has_symbol_property(key);
+        case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->has_symbol_property(key);
+        default: return false;
+        }
+    }
+    return has_property(key.to_std_string());
+}
+
+AnyValue AnyValue::get_own_property(uint32_t idx) const {
+    if (is_array()) return as_array()->get_property(idx);
+    if (is_string()) return as_string()->get_property(idx);
+    return get_own_property(std::to_string(idx));
+}
+
+AnyValue AnyValue::get_own_property(const AnyValue &key) const {
+    if (key.is_number() && is_array()) return as_array()->get_property(key.as_double());
+    if (key.is_number() && is_string()) return as_string()->get_property(key.as_double());
+    if (key.is_symbol()) return get_own_symbol_property(key);
+    return get_own_property(key.to_std_string());
+}
+
+AnyValue AnyValue::get_own_symbol_property(const AnyValue &key) const {
+    return get_symbol_property_with_receiver(key, *this);
+}
+
+AnyValue AnyValue::get_property_with_receiver(const std::string &key, AnyValue receiver) const {
+    switch (get_type()) {
+    case JsType::Object: return as_object()->get_property(key, receiver);
+    case JsType::Array: return as_array()->get_property(key, receiver);
+    case JsType::Function: return as_function()->get_property(key, receiver);
+    case JsType::Promise: return as_promise()->get_property(key, receiver);
+    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_property(key, receiver);
+    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_property(key, receiver);
+    case JsType::Symbol: return as_symbol()->get_property(key, receiver);
+    case JsType::String: return as_string()->get_property(key, receiver);
+    case JsType::Number: {
+        auto proto_it = NumberPrototypes::get(key);
+        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
+        return Constants::UNDEFINED;
+    }
+    case JsType::Undefined: throw Exception::make_exception("Cannot read properties of undefined (reading '" + key + "')", "TypeError");
+    case JsType::Null: throw Exception::make_exception("Cannot read properties of null (reading '" + key + "')", "TypeError");
+    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>");
+    default: return Constants::UNDEFINED;
+    }
+}
+
+AnyValue AnyValue::get_symbol_property_with_receiver(const AnyValue &key, AnyValue receiver) const {
+    switch (get_type()) {
+    case JsType::Object: return as_object()->get_symbol_property(key, receiver);
+    case JsType::Array: return as_array()->get_symbol_property(key, receiver);
+    case JsType::Function: return as_function()->get_symbol_property(key, receiver);
+    case JsType::Promise: return as_promise()->get_symbol_property(key, receiver);
+    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->get_symbol_property(key, receiver);
+    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->get_symbol_property(key, receiver);
+    case JsType::Symbol: {
+        auto proto_it = SymbolPrototypes::get(key);
+        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+        return Constants::UNDEFINED;
+    }
+    case JsType::String: {
+        auto proto_it = StringPrototypes::get(key);
+        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+        return Constants::UNDEFINED;
+    }
+    case JsType::Number: {
+        auto proto_it = NumberPrototypes::get(key);
+        if (proto_it.has_value()) return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key.to_std_string());
+        return Constants::UNDEFINED;
+    }
+    case JsType::Undefined: throw Exception::make_exception("Cannot read properties of undefined (reading Symbol)", "TypeError");
+    case JsType::Null: throw Exception::make_exception("Cannot read properties of null (reading Symbol)", "TypeError");
+    case JsType::Uninitialized: Exception::throw_uninitialized_reference("#<Object>");
+    default: return Constants::UNDEFINED;
+    }
+}
+
+AnyValue AnyValue::set_own_property(const std::string &key, AnyValue value) const {
+    switch (get_type()) {
+    case JsType::Object: return as_object()->set_property(key, value, *this);
+    case JsType::Array: return as_array()->set_property(key, value, *this);
+    case JsType::Function: return as_function()->set_property(key, value, *this);
+    case JsType::Promise: return as_promise()->set_property(key, value, *this);
+    case JsType::Undefined: throw Exception::make_exception("Cannot set properties of undefined (setting '" + key + "')", "TypeError");
+    case JsType::Null: throw Exception::make_exception("Cannot set properties of null (setting '" + key + "')", "TypeError");
+    default: return value;
+    }
+}
+
+AnyValue AnyValue::set_own_property(uint32_t idx, AnyValue value) const {
+    if (is_array()) return as_array()->set_property(idx, value);
+    return set_own_property(std::to_string(idx), value);
+}
+
+AnyValue AnyValue::set_own_property(const AnyValue &key, AnyValue value) const {
+    if (key.is_number() && is_array()) return as_array()->set_property(key.as_double(), value);
+    if (key.is_symbol()) return set_own_symbol_property(key, value);
+    return set_own_property(key.to_std_string(), value);
+}
+
+AnyValue AnyValue::set_own_symbol_property(const AnyValue &key, AnyValue value) const {
+    switch (get_type()) {
+    case JsType::Object: return as_object()->set_symbol_property(key, value, *this);
+    case JsType::Array: return as_array()->set_symbol_property(key, value, *this);
+    case JsType::Function: return as_function()->set_symbol_property(key, value, *this);
+    case JsType::Promise: return as_promise()->set_symbol_property(key, value, *this);
+    case JsType::Iterator: return static_cast<JsIterator<AnyValue> *>(get_ptr())->set_symbol_property(key, value, *this);
+    case JsType::AsyncIterator: return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr())->set_symbol_property(key, value, *this);
+    case JsType::Undefined: throw Exception::make_exception("Cannot set properties of undefined (setting Symbol)", "TypeError");
+    case JsType::Null: throw Exception::make_exception("Cannot set properties of null (setting Symbol)", "TypeError");
+    default: return value;
+    }
+}
+
+AnyValue AnyValue::call_own_property(const std::string &key, std::span<const AnyValue> args) const {
+    return get_own_property(key).call((*this), args, key);
+}
+AnyValue AnyValue::call_own_property(uint32_t idx, std::span<const AnyValue> args) const {
+    if (is_array()) return as_array()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+    if (is_string()) return as_string()->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+    return call_own_property(std::to_string(idx), args);
+}
+AnyValue AnyValue::call_own_property(const AnyValue &key, std::span<const AnyValue> args) const {
+    if (key.is_number() && is_array()) return as_array()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
+    if (key.is_number() && is_string()) return as_string()->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
+    if (key.is_symbol()) return get_own_symbol_property(key).call((*this), args, key.to_std_string());
+    return call_own_property(key.to_std_string(), args);
+}
+
+// --- AnyValue methods that were in any_value_defines.hpp ---
+
+void AnyValue::define_data_property(const std::string &key, AnyValue value) {
+    if (is_object()) {
+        auto obj = as_object();
+        auto offset = obj->shape->get_offset(key);
+        if (offset.has_value()) obj->storage[offset.value()] = value;
+        else {
+            obj->shape = obj->shape->transition(key);
+            obj->storage.push_back(value);
+        }
+    } else if (is_function()) as_function()->props[key] = value;
+}
+
+void AnyValue::define_data_property(const AnyValue &key, AnyValue value) {
+    if (key.is_symbol()) {
+        if (is_object()) as_object()->symbol_props[key] = value;
+        else if (is_function()) as_function()->symbol_props[key] = value;
+    } else define_data_property(key.to_std_string(), value);
+}
+
+void AnyValue::define_data_property(const std::string &key, AnyValue value, bool writable, bool enumerable, bool configurable) {
+    define_data_property(key, AnyValue::make_data_descriptor(value, writable, enumerable, configurable));
+}
+
+void AnyValue::define_getter(const std::string &key, AnyValue getter) {
+    if (is_object()) {
+        auto obj = as_object();
+        auto offset = obj->shape->get_offset(key);
+        if (offset.has_value()) {
+            auto &val = obj->storage[offset.value()];
+            if (val.is_accessor_descriptor()) {
+                auto desc = val.as_accessor_descriptor();
+                desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
+            } else {
+                auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
+                obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+            }
+        } else {
+            auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
+            obj->shape = obj->shape->transition(key);
+            obj->storage.push_back(AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true));
+        }
+    } else if (is_function()) {
+        auto &props = as_function()->props;
+        auto it = props.find(key);
+        if (it != props.end() && it->second.is_accessor_descriptor()) {
+            auto desc = it->second.as_accessor_descriptor();
+            desc->get = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
+        } else {
+            auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
+            props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+        }
+    }
+}
+
+void AnyValue::define_data_property(const AnyValue &key, AnyValue value, bool writable, bool enumerable, bool configurable) {
+    if (key.is_symbol()) {
+        auto desc = AnyValue::make_data_descriptor(value, writable, enumerable, configurable);
+        if (is_object()) as_object()->symbol_props[key] = desc;
+        else if (is_function()) as_function()->symbol_props[key] = desc;
+    } else define_data_property(key.to_std_string(), value, writable, enumerable, configurable);
+}
+
+void AnyValue::define_getter(const AnyValue &key, AnyValue getter) {
+    if (key.is_symbol()) {
+        auto getFunc = [getter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue { return getter.call(thisVal, args); };
+        auto desc = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+        if (is_object()) as_object()->symbol_props[key] = desc;
+        else if (is_function()) as_function()->symbol_props[key] = desc;
+    } else define_getter(key.to_std_string(), getter);
+}
+
+void AnyValue::define_setter(const std::string &key, AnyValue setter) {
+    if (is_object()) {
+        auto obj = as_object();
+        auto offset = obj->shape->get_offset(key);
+        if (offset.has_value()) {
+            auto &val = obj->storage[offset.value()];
+            if (val.is_accessor_descriptor()) {
+                auto desc = val.as_accessor_descriptor();
+                desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
+                    if (args.empty()) return Constants::UNDEFINED;
+                    return setter.call(thisVal, args);
+                };
+            } else {
+                auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+                    if (args.empty()) return jspp::Constants::UNDEFINED;
+                    return setter.call(thisVal, args);
+                };
+                obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+            }
+        } else {
+            auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+                if (args.empty()) return jspp::Constants::UNDEFINED;
+                return setter.call(thisVal, args);
+            };
+            obj->shape = obj->shape->transition(key);
+            obj->storage.push_back(AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true));
+        }
+    } else if (is_function()) {
+        auto &props = as_function()->props;
+        auto it = props.find(key);
+        if (it != props.end() && it->second.is_accessor_descriptor()) {
+            auto desc = it->second.as_accessor_descriptor();
+            desc->set = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
+                if (args.empty()) return Constants::UNDEFINED;
+                return setter.call(thisVal, args);
+            };
+        } else {
+            auto setFunc = [setter](AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+                if (args.empty()) return jspp::Constants::UNDEFINED;
+                return setter.call(thisVal, args);
+            };
+            props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+        }
+    }
+}
+
+void AnyValue::define_setter(const AnyValue &key, AnyValue setter) {
+    if (key.is_symbol()) {
+        auto setFunc = [setter](AnyValue thisVal, std::span<const AnyValue> args) -> AnyValue {
+            if (args.empty()) return Constants::UNDEFINED;
+            return setter.call(thisVal, args);
+        };
+        auto desc = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+        if (is_object()) as_object()->symbol_props[key] = desc;
+        else if (is_function()) as_function()->symbol_props[key] = desc;
+    } else define_setter(key.to_std_string(), setter);
+}
+
+// AnyValue iterator methods from runtime.cpp
+JsIterator<AnyValue>* AnyValue::as_iterator() const noexcept { 
+    return static_cast<JsIterator<AnyValue> *>(get_ptr()); 
+}
+
+JsAsyncIterator<AnyValue>* AnyValue::as_async_iterator() const noexcept { 
+    return static_cast<JsAsyncIterator<AnyValue> *>(get_ptr()); 
+}
+
+} // namespace jspp