@ugo-studio/jspp 0.1.1 → 0.1.3

package/src/prelude/any_value.hpp

@@ -11,18 +11,23 @@
 #include <memory>
 #include <utility>
 #include <string>
-#include <unordered_map>
+#include <map>
 #include <vector>
 #include <functional>
 #include <cmath>
+#include <optional>
 
 #include "types.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #include "values/array.hpp"
 #include "values/function.hpp"
+#include "values/iterator.hpp"
+#include "values/symbol.hpp"
+#include "values/string.hpp"
 #include "error.hpp"
 #include "descriptors.hpp"
+#include "well_known_symbols.hpp"
 
 namespace jspp
 {
@@ -37,8 +42,10 @@ namespace jspp
         Object = 6,
         Array = 7,
         Function = 8,
-        DataDescriptor = 9,
-        AccessorDescriptor = 10,
+        Iterator = 9,
+        Symbol = 10,
+        DataDescriptor = 11,
+        AccessorDescriptor = 12,
     };
 
     // Tagged storage with a union for payload
@@ -52,10 +59,12 @@ namespace jspp
             JsUninitialized uninitialized;
             bool boolean;
             double number;
-            std::unique_ptr<std::string> str;
+            std::shared_ptr<JsString> str;
             std::shared_ptr<JsObject> object;
             std::shared_ptr<JsArray> array;
             std::shared_ptr<JsFunction> function;
+            std::shared_ptr<JsIterator<AnyValue>> iterator;
+            std::shared_ptr<JsSymbol> symbol;
             std::shared_ptr<DataDescriptor> data_desc;
             std::shared_ptr<AccessorDescriptor> accessor_desc;
         };
@@ -74,7 +83,7 @@ namespace jspp
             switch (storage.type)
             {
             case JsType::String:
-                storage.str.~unique_ptr();
+                storage.str.~shared_ptr();
                 break;
             case JsType::Object:
                 storage.object.~shared_ptr();
@@ -85,6 +94,12 @@ namespace jspp
             case JsType::Function:
                 storage.function.~shared_ptr();
                 break;
+            case JsType::Iterator:
+                storage.iterator.~shared_ptr();
+                break;
+            case JsType::Symbol:
+                storage.symbol.~shared_ptr();
+                break;
             case JsType::DataDescriptor:
                 storage.data_desc.~shared_ptr();
                 break;
@@ -124,7 +139,7 @@ namespace jspp
                 storage.number = other.storage.number;
                 break;
             case JsType::String:
-                new (&storage.str) std::unique_ptr<std::string>(std::move(other.storage.str));
+                new (&storage.str) std::shared_ptr<JsString>(std::move(other.storage.str));
                 break;
             case JsType::Object:
                 new (&storage.object) std::shared_ptr<JsObject>(std::move(other.storage.object));
@@ -135,6 +150,12 @@ namespace jspp
             case JsType::Function:
                 new (&storage.function) std::shared_ptr<JsFunction>(std::move(other.storage.function));
                 break;
+            case JsType::Iterator:
+                new (&storage.iterator) std::shared_ptr<JsIterator<AnyValue>>(std::move(other.storage.iterator));
+                break;
+            case JsType::Symbol:
+                new (&storage.symbol) std::shared_ptr<JsSymbol>(std::move(other.storage.symbol));
+                break;
             case JsType::DataDescriptor:
                 new (&storage.data_desc) std::shared_ptr<DataDescriptor>(std::move(other.storage.data_desc));
                 break;
@@ -165,7 +186,7 @@ namespace jspp
                 storage.number = other.storage.number;
                 break;
             case JsType::String:
-                new (&storage.str) std::unique_ptr<std::string>(std::make_unique<std::string>(*other.storage.str));
+                new (&storage.str) std::shared_ptr<JsString>(std::make_shared<JsString>(*other.storage.str));
                 break;
             case JsType::Object:
                 new (&storage.object) std::shared_ptr<JsObject>(other.storage.object); // shallow copy
@@ -176,6 +197,12 @@ namespace jspp
             case JsType::Function:
                 new (&storage.function) std::shared_ptr<JsFunction>(other.storage.function); // shallow copy
                 break;
+            case JsType::Iterator:
+                new (&storage.iterator) std::shared_ptr<JsIterator<AnyValue>>(other.storage.iterator); // shallow copy
+                break;
+            case JsType::Symbol:
+                new (&storage.symbol) std::shared_ptr<JsSymbol>(other.storage.symbol); // shallow copy (shared)
+                break;
             case JsType::DataDescriptor:
                 new (&storage.data_desc) std::shared_ptr<DataDescriptor>(other.storage.data_desc); // shallow copy
                 break;
@@ -291,10 +318,10 @@ namespace jspp
         {
             AnyValue v;
             v.storage.type = JsType::String;
-            new (&v.storage.str) std::unique_ptr<std::string>(std::make_unique<std::string>(raw_s));
+            new (&v.storage.str) std::shared_ptr<JsString>(std::make_shared<JsString>(raw_s));
             return v;
         }
-        static AnyValue make_object(const std::unordered_map<std::string, AnyValue> &props) noexcept
+        static AnyValue make_object(const std::map<std::string, AnyValue> &props) noexcept
         {
             AnyValue v;
             v.storage.type = JsType::Object;
@@ -308,13 +335,27 @@ namespace jspp
             new (&v.storage.array) std::shared_ptr<JsArray>(std::make_shared<JsArray>(dense));
             return v;
         }
-        static AnyValue make_function(const std::function<AnyValue(const std::vector<AnyValue> &)> &call, const std::string &name) noexcept
+        static AnyValue make_function(const JsFunctionCallable &call, const std::string &name) noexcept
         {
             AnyValue v;
             v.storage.type = JsType::Function;
             new (&v.storage.function) std::shared_ptr<JsFunction>(std::make_shared<JsFunction>(call, name));
             return v;
         }
+        static AnyValue make_generator(const JsFunctionCallable &call, const std::string &name) noexcept
+        {
+            AnyValue v;
+            v.storage.type = JsType::Function;
+            new (&v.storage.function) std::shared_ptr<JsFunction>(std::make_shared<JsFunction>(call, true, name));
+            return v;
+        }
+        static AnyValue make_symbol(const std::string &description = "") noexcept
+        {
+            AnyValue v;
+            v.storage.type = JsType::Symbol;
+            new (&v.storage.symbol) std::shared_ptr<JsSymbol>(std::make_shared<JsSymbol>(description));
+            return v;
+        }
         static AnyValue make_data_descriptor(const AnyValue &value, bool writable, bool enumerable, bool configurable) noexcept
         {
             AnyValue v;
@@ -333,6 +374,35 @@ namespace jspp
             return v;
         }
 
+        static AnyValue from_symbol(std::shared_ptr<JsSymbol> sym) noexcept
+        {
+            AnyValue v;
+            v.storage.type = JsType::Symbol;
+            new (&v.storage.symbol) std::shared_ptr<JsSymbol>(std::move(sym));
+            return v;
+        }
+        static AnyValue from_string(std::shared_ptr<JsString> str) noexcept
+        {
+            AnyValue v;
+            v.storage.type = JsType::String;
+            new (&v.storage.str) std::shared_ptr<JsString>(std::move(str));
+            return v;
+        }
+        static AnyValue from_iterator(JsIterator<AnyValue> &&iterator) noexcept
+        {
+            AnyValue v;
+            v.storage.type = JsType::Iterator;
+            new (&v.storage.iterator) std::shared_ptr<JsIterator<AnyValue>>(std::make_shared<JsIterator<AnyValue>>(std::move(iterator)));
+            return v;
+        }
+        static AnyValue from_iterator_ref(JsIterator<AnyValue> *iterator) noexcept
+        {
+            AnyValue v;
+            v.storage.type = JsType::Iterator;
+            new (&v.storage.iterator) std::shared_ptr<JsIterator<AnyValue>>(iterator, [](JsIterator<AnyValue> *) {});
+            return v;
+        }
+
         // property resolution helpers ---------------------------------------
         static AnyValue resolve_property_for_read(const AnyValue &val) noexcept
         {
@@ -393,12 +463,15 @@ namespace jspp
         bool is_object() const noexcept { return storage.type == JsType::Object; }
         bool is_array() const noexcept { return storage.type == JsType::Array; }
         bool is_function() const noexcept { return storage.type == JsType::Function; }
+        bool is_iterator() const noexcept { return storage.type == JsType::Iterator; }
         bool is_boolean() const noexcept { return storage.type == JsType::Boolean; }
+        bool is_symbol() const noexcept { return storage.type == JsType::Symbol; }
         bool is_null() const noexcept { return storage.type == JsType::Null; }
         bool is_undefined() const noexcept { return storage.type == JsType::Undefined; }
         bool is_uninitialized() const noexcept { return storage.type == JsType::Uninitialized; }
         bool is_data_descriptor() const noexcept { return storage.type == JsType::DataDescriptor; }
         bool is_accessor_descriptor() const noexcept { return storage.type == JsType::AccessorDescriptor; }
+        bool is_generator() const noexcept { return storage.type == JsType::Function && storage.function->is_generator; }
 
         // --- TYPE CASTERS
         double as_double() const noexcept
@@ -411,7 +484,7 @@ namespace jspp
             assert(is_boolean());
             return storage.boolean;
         }
-        std::string *as_string() const noexcept
+        JsString *as_string() const noexcept
         {
             assert(is_string());
             return storage.str.get();
@@ -426,11 +499,21 @@ namespace jspp
             assert(is_array());
             return storage.array.get();
         }
-        JsFunction *as_function(const std::string &expression = "") const
+        JsFunction *as_function(const std::optional<std::string> &expression = std::nullopt) const
         {
             if (is_function())
                 return storage.function.get();
-            throw RuntimeError::make_error(expression + " is not a function", "TypeError");
+            throw RuntimeError::make_error(expression.value_or(to_std_string()) + " is not a function", "TypeError");
+        }
+        JsSymbol *as_symbol() const noexcept
+        {
+            assert(is_symbol());
+            return storage.symbol.get();
+        }
+        std::shared_ptr<JsIterator<AnyValue>> as_iterator() const
+        {
+            assert(is_iterator());
+            return storage.iterator; // Returns the shared_ptr, incrementing ref count
         }
         DataDescriptor *as_data_descriptor() const noexcept
         {
@@ -444,31 +527,22 @@ namespace jspp
         }
 
         // --- PROPERTY ACCESS OPERATORS
-        AnyValue get_own_property(const std::string &key)
+        AnyValue get_own_property(const std::string &key) const
         {
             switch (storage.type)
             {
             case JsType::Object:
-                return as_object()->get_property(key);
+                return storage.object->get_property(key);
             case JsType::Array:
-                return as_array()->get_property(key);
+                return storage.array->get_property(key);
             case JsType::Function:
-                return as_function()->get_property(key);
+                return storage.function->get_property(key);
+            case JsType::Iterator:
+                return storage.iterator->get_property(key);
+            case JsType::Symbol:
+                return storage.symbol->get_property(key);
             case JsType::String:
-            {
-                // Check for prototype methods
-                auto proto_fn = StringPrototypes::get(key, this->storage.str);
-                if (proto_fn.has_value())
-                {
-                    return resolve_property_for_read(proto_fn.value());
-                }
-                // Handle character access by string index (e.g., "abc"["1"])
-                if (JsArray::is_array_index(key))
-                {
-                    uint32_t idx = static_cast<uint32_t>(std::stoull(key));
-                    return get_own_property(idx);
-                }
-            }
+                return storage.str->get_property(key);
             case JsType::Undefined:
                 throw RuntimeError::make_error("Cannot read properties of undefined (reading '" + key + "')", "TypeError");
             case JsType::Null:
@@ -477,41 +551,42 @@ namespace jspp
                 return AnyValue::make_undefined();
             }
         }
-        AnyValue get_own_property(uint32_t idx) noexcept
+        AnyValue get_own_property(uint32_t idx) const noexcept
         {
             switch (storage.type)
             {
             case JsType::Array:
-                return as_array()->get_property(idx);
-            case JsType::String: // Handle character access by index (e.g., "abc"[1])
-            {
-                if (idx < storage.str->length())
-                {
-                    return AnyValue::make_string(std::string(1, (*storage.str)[idx]));
-                }
-                return AnyValue::make_undefined();
-            }
+                return storage.array->get_property(idx);
+            case JsType::String:
+                return storage.str->get_property(idx);
             default:
                 return get_own_property(std::to_string(idx));
             }
         }
-        AnyValue get_own_property(const AnyValue &key) noexcept
+        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);
+
+            // 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);
+
             return get_own_property(key.to_std_string());
         }
         // for setting values
-        AnyValue set_own_property(const std::string &key, const AnyValue &value)
+        AnyValue set_own_property(const std::string &key, const AnyValue &value) const
         {
             switch (storage.type)
             {
             case JsType::Object:
-                return as_object()->set_property(key, value);
+                return storage.object->set_property(key, value);
             case JsType::Array:
-                return as_array()->set_property(key, value);
+                return storage.array->set_property(key, value);
             case JsType::Function:
-                return as_function()->set_property(key, value);
+                return storage.function->set_property(key, value);
             case JsType::Undefined:
                 throw RuntimeError::make_error("Cannot set properties of undefined (setting '" + key + "')", "TypeError");
             case JsType::Null:
@@ -520,215 +595,40 @@ namespace jspp
                 return value;
             }
         }
-        AnyValue set_own_property(uint32_t idx, const AnyValue &value)
+        AnyValue set_own_property(uint32_t idx, const AnyValue &value) const
         {
             if (storage.type == JsType::Array)
             {
-                return as_array()->set_property(idx, value);
+                return storage.array->set_property(idx, value);
             }
             return set_own_property(std::to_string(idx), value);
         }
-        AnyValue set_own_property(const AnyValue &key, const AnyValue &value)
+        AnyValue set_own_property(const AnyValue &key, const AnyValue &value) const
         {
             if (key.storage.type == JsType::Number && storage.type == JsType::Array)
             {
                 return storage.array->set_property(key.storage.number, value);
             }
+
+            // 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);
+
             return set_own_property(key.to_std_string(), value);
         }
 
         // --- HELPERS
-        const bool is_truthy() const noexcept
-        {
-            switch (storage.type)
-            {
-            case JsType::Boolean:
-                return storage.boolean;
-            case JsType::Number:
-                return storage.number != 0.0;
-            case JsType::String:
-                return !storage.str->empty();
-            default:
-                return true;
-            }
-        }
-        const bool is_strictly_equal_to(const AnyValue &other) const noexcept
-        {
-            if (storage.type == other.storage.type)
-            {
-                switch (storage.type)
-                {
-                case JsType::Boolean:
-                    return storage.boolean == other.storage.boolean;
-                case JsType::Number:
-                    return storage.number == other.storage.number;
-                case JsType::String:
-                    return (*storage.str.get() == *other.storage.str.get());
-                case JsType::Array:
-                    return (storage.array == other.storage.array);
-                case JsType::Object:
-                    return (storage.object == other.storage.object);
-                case JsType::Function:
-                    return (storage.function == other.storage.function);
-                default:
-                    return true;
-                }
-            }
-            return false;
-        }
-        const bool is_equal_to(const AnyValue &other) const noexcept
-        {
-            // Implements JavaScript's Abstract Equality Comparison Algorithm (==)
-            // Step 1: If types are the same, use strict equality (===)
-            if (storage.type == other.storage.type)
-            {
-                return is_strictly_equal_to(other);
-            }
-            // Steps 2 & 3: null == undefined
-            if ((is_null() && other.is_undefined()) || (is_undefined() && other.is_null()))
-            {
-                return true;
-            }
-            // Step 4 & 5: number == string
-            if (is_number() && other.is_string())
-            {
-                double num_this = this->as_double();
-                double num_other;
-                try
-                {
-                    const std::string &s = *other.as_string();
-                    // JS considers empty string or whitespace-only string to be 0
-                    if (s.empty() || std::all_of(s.begin(), s.end(), [](unsigned char c)
-                                                 { return std::isspace(c); }))
-                    {
-                        num_other = 0.0;
-                    }
-                    else
-                    {
-                        size_t pos;
-                        num_other = std::stod(s, &pos);
-                        // Check if the entire string was consumed, allowing for trailing whitespace
-                        while (pos < s.length() && std::isspace(static_cast<unsigned char>(s[pos])))
-                        {
-                            pos++;
-                        }
-                        if (pos != s.length())
-                        {
-                            num_other = std::numeric_limits<double>::quiet_NaN();
-                        }
-                    }
-                }
-                catch (...)
-                {
-                    num_other = std::numeric_limits<double>::quiet_NaN();
-                }
-                return num_this == num_other;
-            }
-            if (is_string() && other.is_number())
-            {
-                // Delegate to the other operand to avoid code duplication
-                return other.is_equal_to(*this);
-            }
-            // Step 6 & 7: boolean == any
-            if (is_boolean())
-            {
-                // Convert boolean to number and re-compare
-                return AnyValue::make_number(as_boolean() ? 1.0 : 0.0).is_equal_to(other);
-            }
-            if (other.is_boolean())
-            {
-                // Convert boolean to number and re-compare
-                return is_equal_to(AnyValue::make_number(other.as_boolean() ? 1.0 : 0.0));
-            }
-            // Step 8 & 9: object == (string or number)
-            if ((other.is_object() || other.is_array() || other.is_function()) && (is_string() || is_number()))
-            {
-                // Delegate to the other operand to avoid code duplication
-                return other.is_equal_to(*this);
-            }
-            if ((is_object() || is_array() || is_function()) && (other.is_string() || other.is_number()))
-            {
-                // Convert object to primitive (string) and re-compare.
-                // This is a simplification of JS's ToPrimitive which would try valueOf() first.
-                return AnyValue::make_string(to_std_string()).is_equal_to(other);
-            }
-            // Step 10: All other cases (e.g., object == null) are false.
-            return false;
-        }
-        const AnyValue is_strictly_equal_to_primitive(const AnyValue &other) const noexcept
-        {
-            return AnyValue::make_boolean(is_strictly_equal_to(other));
-        }
-        const AnyValue is_equal_to_primitive(const AnyValue &other) const noexcept
-        {
-            return AnyValue::make_boolean(is_equal_to(other));
-        }
-        const AnyValue not_strictly_equal_to_primitive(const AnyValue &other) const noexcept
-        {
-            return AnyValue::make_boolean(!is_strictly_equal_to(other));
-        }
-        const AnyValue not_equal_to_primitive(const AnyValue &other) const noexcept
-        {
-            return AnyValue::make_boolean(!is_equal_to(other));
-        }
-        const std::string to_std_string() const noexcept
-        {
-            switch (storage.type)
-            {
-            case JsType::Undefined:
-                return "undefined";
-            case JsType::Null:
-                return "null";
-            case JsType::Boolean:
-                return storage.boolean ? "true" : "false";
-            case JsType::String:
-                return *storage.str.get();
-            case JsType::Object:
-                return storage.object->to_std_string();
-            case JsType::Array:
-                return storage.array->to_std_string();
-            case JsType::Function:
-                return storage.function->to_std_string();
-            case JsType::DataDescriptor:
-                return storage.data_desc->value->to_std_string();
-            case JsType::AccessorDescriptor:
-            {
-                if (storage.accessor_desc->get.has_value())
-                    return storage.accessor_desc->get.value()({}).to_std_string();
-                else
-                    return "undefined";
-            }
-            case JsType::Number:
-            {
-                if (std::isnan(storage.number))
-                {
-                    return "NaN";
-                }
-                if (std::abs(storage.number) >= 1e21 || (std::abs(storage.number) > 0 && std::abs(storage.number) < 1e-6))
-                {
-                    std::ostringstream oss;
-                    oss << std::scientific << std::setprecision(4) << storage.number;
-                    return oss.str();
-                }
-                else
-                {
-                    std::ostringstream oss;
-                    oss << std::setprecision(6) << std::fixed << storage.number;
-                    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;
-                }
-            }
-            // Uninitialized and default should not be reached under normal circumstances
-            case JsType::Uninitialized:
-                return "<uninitialized>";
-            default:
-                return "";
-            }
-        }
+        const bool is_truthy() const noexcept;
+
+        const bool is_strictly_equal_to(const AnyValue &other) const noexcept;
+        const bool is_equal_to(const AnyValue &other) const noexcept;
+
+        const AnyValue is_strictly_equal_to_primitive(const AnyValue &other) const noexcept;
+        const AnyValue is_equal_to_primitive(const AnyValue &other) const noexcept;
+
+        const AnyValue not_strictly_equal_to_primitive(const AnyValue &other) const noexcept;
+        const AnyValue not_equal_to_primitive(const AnyValue &other) const noexcept;
+
+        const std::string to_std_string() const noexcept;
     };
 }