@ugo-studio/jspp 0.1.4 → 0.1.6

package/src/prelude/any_value_access.hpp

@@ -3,101 +3,188 @@
 #include "types.hpp"
 #include "any_value.hpp"
 
-jspp::AnyValue jspp::AnyValue::get_own_property(const std::string &key) const
+namespace jspp
 {
-    return get_property_with_receiver(key, *this);
-}
-jspp::AnyValue jspp::AnyValue::get_own_property(uint32_t idx) const noexcept
-{
-    switch (storage.type)
+    AnyValue AnyValue::get_own_property(const std::string &key) const
     {
-    case JsType::Array:
-        return storage.array->get_property(idx);
-    case JsType::String:
-        return storage.str->get_property(idx);
-    default:
-        return get_own_property(std::to_string(idx));
+        return get_property_with_receiver(key, *this);
     }
-}
-jspp::AnyValue jspp::AnyValue::get_own_property(const AnyValue &key) const noexcept
-{
-    if (key.storage.type == JsType::Number && storage.type == JsType::Array)
-        return storage.array->get_property(key.storage.number);
-    if (key.storage.type == JsType::Number && storage.type == JsType::String)
-        return storage.str->get_property(key.storage.number);
+    bool AnyValue::has_property(const std::string &key) const
+    {
+        switch (get_type())
+        {
+        case JsType::Object:
+            return std::get<std::shared_ptr<JsObject>>(storage)->has_property(key);
+        case JsType::Array:
+            return std::get<std::shared_ptr<JsArray>>(storage)->has_property(key);
+        case JsType::Function:
+            return std::get<std::shared_ptr<JsFunction>>(storage)->has_property(key);
+        case JsType::Promise:
+            // Promises don't have their own props usually, but could.
+            return false;
+        case JsType::Iterator:
+            return false;
+        case JsType::AsyncIterator:
+            return false;
+        case JsType::Symbol:
+            return false;
+        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 < std::get<std::shared_ptr<JsString>>(storage)->value.length();
+            }
+            return false;
+        case JsType::Number:
+            return false;
+        case JsType::Uninitialized:
+            Exception::throw_uninitialized_reference("#<Object>");
+            return false;
+        default:
+            return false;
+        }
+    }
+    AnyValue AnyValue::get_own_property(uint32_t idx) const
+    {
+        switch (storage.index())
+        {
+        case 7: // Array
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(idx);
+        case 5: // String
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(idx);
+        case 4: // Number
+            return get_own_property(std::to_string(idx));
+        default:
+            return get_own_property(std::to_string(idx));
+        }
+    }
+    AnyValue AnyValue::get_own_property(const AnyValue &key) const
+    {
+        if (key.is_number() && is_array())
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key.as_double());
+        if (key.is_number() && is_string())
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(key.as_double());
 
-    // If the key is a Symbol, use its internal key string
-    if (key.storage.type == JsType::Symbol)
-        return get_own_property(key.storage.symbol->key);
+        // If the key is a Symbol, use its internal key string
+        if (key.is_symbol())
+            return get_own_property(key.as_symbol()->key);
 
-    return get_own_property(key.to_std_string());
-}
+        return get_own_property(key.to_std_string());
+    }
 
-jspp::AnyValue jspp::AnyValue::get_property_with_receiver(const std::string &key, const AnyValue &receiver) const
-{
-    switch (storage.type)
+    AnyValue AnyValue::get_property_with_receiver(const std::string &key, const AnyValue &receiver) const
     {
-    case JsType::Object:
-        return storage.object->get_property(key, receiver);
-    case JsType::Array:
-        return storage.array->get_property(key, receiver);
-    case JsType::Function:
-        return storage.function->get_property(key, receiver);
-    case JsType::Promise:
-        return storage.promise->get_property(key, receiver);
-    case JsType::Iterator:
-        return storage.iterator->get_property(key, receiver);
-    case JsType::Symbol:
-        return storage.symbol->get_property(key, receiver);
-    case JsType::String:
-        return storage.str->get_property(key, receiver);
-    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");
-    default:
-        return AnyValue::make_undefined();
+        switch (get_type())
+        {
+        case JsType::Object:
+            return std::get<std::shared_ptr<JsObject>>(storage)->get_property(key, receiver);
+        case JsType::Array:
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(key, receiver);
+        case JsType::Function:
+            return std::get<std::shared_ptr<JsFunction>>(storage)->get_property(key, receiver);
+        case JsType::Promise:
+            return std::get<std::shared_ptr<JsPromise>>(storage)->get_property(key, receiver);
+        case JsType::Iterator:
+            return std::get<std::shared_ptr<JsIterator<AnyValue>>>(storage)->get_property(key, receiver);
+        case JsType::AsyncIterator:
+            return std::get<std::shared_ptr<JsAsyncIterator<AnyValue>>>(storage)->get_property(key, receiver);
+        case JsType::Symbol:
+            return std::get<std::shared_ptr<JsSymbol>>(storage)->get_property(key, receiver);
+        case JsType::String:
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(key, receiver);
+        case JsType::Number:
+        {
+            auto proto_it = NumberPrototypes::get(key, std::get<double>(storage));
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), receiver, key);
+            }
+            return AnyValue::make_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 AnyValue::make_undefined();
+        }
     }
-}
 
-jspp::AnyValue jspp::AnyValue::set_own_property(const std::string &key, const AnyValue &value) const
-{
-    switch (storage.type)
+    AnyValue AnyValue::set_own_property(const std::string &key, const AnyValue &value) const
     {
-    case JsType::Object:
-        return storage.object->set_property(key, value, *this);
-    case JsType::Array:
-        return storage.array->set_property(key, value, *this);
-    case JsType::Function:
-        return storage.function->set_property(key, value, *this);
-    case JsType::Promise:
-        return storage.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;
+        switch (get_type())
+        {
+        case JsType::Object:
+            return std::get<std::shared_ptr<JsObject>>(storage)->set_property(key, value, *this);
+        case JsType::Array:
+            return std::get<std::shared_ptr<JsArray>>(storage)->set_property(key, value, *this);
+        case JsType::Function:
+            return std::get<std::shared_ptr<JsFunction>>(storage)->set_property(key, value, *this);
+        case JsType::Promise:
+            return std::get<std::shared_ptr<JsPromise>>(storage)->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;
+        }
     }
-}
-jspp::AnyValue jspp::AnyValue::set_own_property(uint32_t idx, const AnyValue &value) const
-{
-    if (storage.type == JsType::Array)
+    AnyValue AnyValue::set_own_property(uint32_t idx, const AnyValue &value) const
     {
-        return storage.array->set_property(idx, value);
+        if (is_array())
+        {
+            return std::get<std::shared_ptr<JsArray>>(storage)->set_property(idx, value);
+        }
+        return set_own_property(std::to_string(idx), value);
     }
-    return set_own_property(std::to_string(idx), value);
-}
-jspp::AnyValue jspp::AnyValue::set_own_property(const AnyValue &key, const AnyValue &value) const
-{
-    if (key.storage.type == JsType::Number && storage.type == JsType::Array)
+    AnyValue AnyValue::set_own_property(const AnyValue &key, const AnyValue &value) const
+    {
+        if (key.is_number() && is_array())
+        {
+            return std::get<std::shared_ptr<JsArray>>(storage)->set_property(key.as_double(), value);
+        }
+
+        // If the key is a Symbol, use its internal key string
+        if (key.is_symbol())
+            return set_own_property(key.as_symbol()->key, value);
+
+        return set_own_property(key.to_std_string(), 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
     {
-        return storage.array->set_property(key.storage.number, value);
+        switch (storage.index())
+        {
+        case 7: // Array
+            return std::get<std::shared_ptr<JsArray>>(storage)->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+        case 5: // String
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(idx).call((*this), args, "[" + std::to_string(idx) + "]");
+        case 4: // Number
+            return call_own_property(std::to_string(idx), args);
+        default:
+            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 std::get<std::shared_ptr<JsArray>>(storage)->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
+        if (key.is_number() && is_string())
+            return std::get<std::shared_ptr<JsString>>(storage)->get_property(key.as_double()).call((*this), args, "[" + key.to_std_string() + "]");
 
-    // If the key is a Symbol, use its internal key string
-    if (key.storage.type == JsType::Symbol)
-        return set_own_property(key.storage.symbol->key, value);
+        // If the key is a Symbol, use its internal key string
+        if (key.is_symbol())
+            return call_own_property(key.as_symbol()->key, args);
 
-    return set_own_property(key.to_std_string(), value);
-}
+        return call_own_property(key.to_std_string(), args);
+    }
+}

package/src/prelude/any_value_defines.hpp

@@ -7,16 +7,25 @@
 
 namespace jspp
 {
-
     inline void AnyValue::define_data_property(const std::string &key, const AnyValue &value)
     {
         if (is_object())
         {
-            storage.object->props[key] = value;
+            auto obj = std::get<std::shared_ptr<JsObject>>(storage);
+            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())
         {
-            storage.function->props[key] = value;
+            std::get<std::shared_ptr<JsFunction>>(storage)->props[key] = value;
         }
     }
 
@@ -37,42 +46,56 @@ namespace jspp
     {
         if (is_object())
         {
-            auto &props = storage.object->props;
-            auto it = props.find(key);
-            if (it != props.end() && it->second.is_accessor_descriptor())
+            auto obj = std::get<std::shared_ptr<JsObject>>(storage);
+            auto offset = obj->shape->get_offset(key);
+
+            if (offset.has_value())
             {
-                auto desc = it->second.as_accessor_descriptor();
-                desc->get = [getter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                auto &val = obj->storage[offset.value()];
+                if (val.is_accessor_descriptor())
                 {
-                    return getter.as_function()->call(thisVal, args);
-                };
+                    auto desc = val.as_accessor_descriptor();
+                    desc->get = [getter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                    {
+                        return getter.call(thisVal, args);
+                    };
+                }
+                else
+                {
+                    auto getFunc = [getter](const 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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                auto getFunc = [getter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                 {
-                    return getter.as_function()->call(thisVal, args);
+                    return getter.call(thisVal, args);
                 };
-                props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
+                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 = storage.function->props;
+            auto &props = std::get<std::shared_ptr<JsFunction>>(storage)->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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                desc->get = [getter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                 {
-                    return getter.as_function()->call(thisVal, args);
+                    return getter.call(thisVal, args);
                 };
             }
             else
             {
-                auto getFunc = [getter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                auto getFunc = [getter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                 {
-                    return getter.as_function()->call(thisVal, args);
+                    return getter.call(thisVal, args);
                 };
                 props[key] = AnyValue::make_accessor_descriptor(getFunc, std::nullopt, true, true);
             }
@@ -91,50 +114,66 @@ namespace jspp
     {
         if (is_object())
         {
-            auto &props = storage.object->props;
-            auto it = props.find(key);
-            if (it != props.end() && it->second.is_accessor_descriptor())
+            auto obj = std::get<std::shared_ptr<JsObject>>(storage);
+            auto offset = obj->shape->get_offset(key);
+
+            if (offset.has_value())
             {
-                auto desc = it->second.as_accessor_descriptor();
-                desc->set = [setter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                auto &val = obj->storage[offset.value()];
+                if (val.is_accessor_descriptor())
                 {
-                    if (args.empty())
-                        return AnyValue::make_undefined();
-                    return setter.as_function()->call(thisVal, args);
-                };
+                    auto desc = val.as_accessor_descriptor();
+                    desc->set = [setter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                    {
+                        if (args.empty())
+                            return AnyValue::make_undefined();
+                        return setter.call(thisVal, args);
+                    };
+                }
+                else
+                {
+                    auto setFunc = [setter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                    {
+                        if (args.empty())
+                            return AnyValue::make_undefined();
+                        return setter.call(thisVal, args);
+                    };
+                    obj->storage[offset.value()] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+                }
             }
             else
             {
-                auto setFunc = [setter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                auto setFunc = [setter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                 {
                     if (args.empty())
                         return AnyValue::make_undefined();
-                    return setter.as_function()->call(thisVal, args);
+                    return setter.call(thisVal, args);
                 };
-                props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
+                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 = storage.function->props;
+            auto &props = std::get<std::shared_ptr<JsFunction>>(storage)->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](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                desc->set = [setter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                 {
                     if (args.empty())
                         return AnyValue::make_undefined();
-                    return setter.as_function()->call(thisVal, args);
+                    return setter.call(thisVal, args);
                 };
             }
             else
             {
-                auto setFunc = [setter](const AnyValue &thisVal, const std::vector<AnyValue> &args) -> AnyValue
+                auto setFunc = [setter](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
                 {
                     if (args.empty())
                         return AnyValue::make_undefined();
-                    return setter.as_function()->call(thisVal, args);
+                    return setter.call(thisVal, args);
                 };
                 props[key] = AnyValue::make_accessor_descriptor(std::nullopt, setFunc, true, true);
             }