@tishlang/tish 1.9.1 → 1.10.0

package/crates/tish_builtins/src/globals.rs

@@ -3,10 +3,8 @@
 //! Used by both tishlang_vm (bytecode) and tishlang_runtime (compiled). Keeps tishlang_vm
 //! independent of tishlang_runtime.
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
-use std::rc::Rc;
 use std::sync::Arc;
+use tishlang_core::VmRef;
 use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
 
 /// Boolean(value) - coerce to bool
@@ -76,6 +74,7 @@ pub fn object_keys(args: &[Value]) -> Value {
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let keys: Vec<Value> = obj_borrow
+            .strings
             .keys()
             .map(|k| Value::String(Arc::clone(k)))
             .collect();
@@ -89,7 +88,7 @@ pub fn object_keys(args: &[Value]) -> Value {
 pub fn object_values(args: &[Value]) -> Value {
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
-        let values: Vec<Value> = obj_borrow.values().cloned().collect();
+        let values: Vec<Value> = obj_borrow.strings.values().cloned().collect();
         Value::Array(VmRef::new(values))
     } else {
         Value::Array(VmRef::new(Vec::new()))
@@ -101,13 +100,9 @@ pub fn object_entries(args: &[Value]) -> Value {
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let entries: Vec<Value> = obj_borrow
+            .strings
             .iter()
-            .map(|(k, v)| {
-                Value::Array(VmRef::new(vec![
-                    Value::String(Arc::clone(k)),
-                    v.clone(),
-                ]))
-            })
+            .map(|(k, v)| Value::Array(VmRef::new(vec![Value::String(Arc::clone(k)), v.clone()])))
             .collect();
         Value::Array(VmRef::new(entries))
     } else {
@@ -127,7 +122,7 @@ pub fn object_assign(args: &[Value]) -> Value {
         .skip(1)
         .map(|source| {
             if let Value::Object(src) = source {
-                src.borrow().len()
+                src.borrow().len_entries()
             } else {
                 0
             }
@@ -135,13 +130,20 @@ pub fn object_assign(args: &[Value]) -> Value {
         .sum();
 
     let mut target_mut = target.borrow_mut();
-    target_mut.reserve(additional_capacity);
+    target_mut.strings.reserve(additional_capacity);
 
     for source in args.iter().skip(1) {
         if let Value::Object(src) = source {
             let src_borrow = src.borrow();
-            for (k, v) in src_borrow.iter() {
-                target_mut.insert(Arc::clone(k), v.clone());
+            for (k, v) in src_borrow.strings.iter() {
+                target_mut.strings.insert(Arc::clone(k), v.clone());
+            }
+            if let Some(ss) = &src_borrow.symbols {
+                if target_mut.symbols.is_none() {
+                    target_mut.symbols = Some(Default::default());
+                }
+                let dst = target_mut.symbols.as_mut().unwrap();
+                dst.extend(ss.iter().map(|(id, v)| (*id, v.clone())));
             }
         }
     }
@@ -204,8 +206,8 @@ pub fn object_from_entries(args: &[Value]) -> Value {
             }
         }
 
-        Value::Object(VmRef::new(obj))
+        Value::object(obj)
     } else {
-        Value::Object(VmRef::new(ObjectMap::default()))
+        Value::empty_object()
     }
 }

package/crates/tish_builtins/src/helpers.rs

@@ -1,8 +1,5 @@
 //! Common helper functions used across builtin implementations.
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
-use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{ObjectMap, Value};
 
@@ -26,7 +23,7 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 pub fn make_error_value(e: impl std::fmt::Display) -> Value {
     let mut obj = ObjectMap::with_capacity(1);
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
-    Value::Object(VmRef::new(obj))
+    Value::object(obj)
 }
 
 /// Extract a number from a Value, returning None for non-numbers.

package/crates/tish_builtins/src/lib.rs

@@ -11,5 +11,6 @@ pub mod helpers;
 pub mod math;
 pub mod object;
 pub mod string;
+pub mod symbol;
 
 pub use tishlang_core::Value;

package/crates/tish_builtins/src/object.rs

@@ -3,34 +3,34 @@
 //! This module will contain shared object method implementations.
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
-use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::{ObjectMap, Value};
+use tishlang_core::{ObjectData, ObjectMap, Value, VmRef};
 
 /// Create a new empty object Value.
 pub fn new() -> Value {
-    Value::Object(VmRef::new(ObjectMap::default()))
+    Value::empty_object()
 }
 
 /// Create a new object Value with a given capacity.
 pub fn with_capacity(capacity: usize) -> Value {
-    Value::Object(VmRef::new(ObjectMap::with_capacity(capacity)))
+    Value::Object(VmRef::new(ObjectData {
+        strings: ObjectMap::with_capacity(capacity),
+        symbols: None,
+    }))
 }
 
-/// Get the keys of an object.
+/// Get the keys of an object (string keys only; matches `Object.keys` in JS).
 pub fn keys(obj: &Value) -> Option<Vec<Arc<str>>> {
     match obj {
-        Value::Object(map) => Some(map.borrow().keys().cloned().collect()),
+        Value::Object(map) => Some(map.borrow().strings.keys().cloned().collect()),
         _ => None,
     }
 }
 
-/// Get the values of an object.
+/// Get the values of an object (string-keyed properties only).
 pub fn values(obj: &Value) -> Option<Vec<Value>> {
     match obj {
-        Value::Object(map) => Some(map.borrow().values().cloned().collect()),
+        Value::Object(map) => Some(map.borrow().strings.values().cloned().collect()),
         _ => None,
     }
 }

package/crates/tish_builtins/src/string.rs

@@ -4,11 +4,9 @@
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
 use crate::helpers::normalize_index;
-use tishlang_core::VmRef;
-use std::cell::RefCell;
-use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::Value;
+use tishlang_core::VmRef;
 
 /// Byte offset -> character index.
 fn byte_to_char_index(s: &str, byte_offset: usize) -> usize {

package/crates/tish_builtins/src/symbol.rs

@@ -0,0 +1,83 @@
+//! ECMAScript-style `Symbol`, `Symbol.for`, `Symbol.keyFor`.
+
+use std::collections::hash_map::Entry;
+use std::sync::{Arc, Mutex, OnceLock};
+
+use std::collections::HashMap;
+
+use tishlang_core::{alloc_symbol_id, ObjectMap, TishSymbol, Value};
+
+static SYMBOL_FOR_REGISTRY: OnceLock<Mutex<HashMap<Arc<str>, Arc<TishSymbol>>>> = OnceLock::new();
+
+fn symbol_registry() -> &'static Mutex<HashMap<Arc<str>, Arc<TishSymbol>>> {
+    SYMBOL_FOR_REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+fn symbol_for_impl(key: &str) -> Value {
+    let k: Arc<str> = key.into();
+    let mut reg = symbol_registry().lock().unwrap();
+    let sym = match reg.entry(Arc::clone(&k)) {
+        Entry::Occupied(e) => e.get().clone(),
+        Entry::Vacant(v) => {
+            let id = alloc_symbol_id();
+            let sym = TishSymbol::new_registry(id, Arc::clone(&k), None);
+            v.insert(Arc::clone(&sym));
+            sym
+        }
+    };
+    Value::Symbol(sym)
+}
+
+fn symbol_new(args: &[Value]) -> Value {
+    let desc = args.first().and_then(|v| {
+        if matches!(v, Value::Null) {
+            None
+        } else {
+            Some(v.to_display_string().into())
+        }
+    });
+    Value::Symbol(TishSymbol::new_unique(desc))
+}
+
+fn symbol_key_for_impl(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Symbol(s)) => s
+            .registry_key
+            .as_ref()
+            .map(|k| Value::String(Arc::clone(k)))
+            .unwrap_or(Value::Null),
+        _ => Value::Null,
+    }
+}
+
+/// Global `Symbol`: `Symbol("desc")` via `__call` / `__construct`, `Symbol.for`, `Symbol.keyFor`.
+pub fn symbol_object() -> Value {
+    let call = Value::native(symbol_new);
+    let for_fn = Value::native(|args: &[Value]| {
+        let key = args
+            .first()
+            .map(|v| v.to_display_string())
+            .unwrap_or_default();
+        symbol_for_impl(&key)
+    });
+    let key_for = Value::native(symbol_key_for_impl);
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("__call"), call.clone());
+    m.insert(Arc::from("__construct"), call);
+    m.insert(Arc::from("for"), for_fn);
+    m.insert(Arc::from("keyFor"), key_for);
+    Value::object(m)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tishlang_core::value_call;
+
+    #[test]
+    fn symbol_global_value_call() {
+        let o = symbol_object();
+        let r = value_call(&o, &[Value::String("hi".into())]);
+        assert!(matches!(r, Value::Symbol(_)));
+    }
+}