@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_builtins/src/array.rs

@@ -1,10 +1,8 @@
 //! Array builtin methods.
 
 use crate::helpers::normalize_index;
-use tishlang_core::VmRef;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tishlang_core::Value;
+use tishlang_core::VmRef;
 
 /// Create a new array Value from a Vec of Values.
 pub fn from_vec(v: Vec<Value>) -> Value {
@@ -434,6 +432,7 @@ fn get_prop_number(v: &Value, prop: &std::sync::Arc<str>) -> f64 {
     match v {
         Value::Object(o) => o
             .borrow()
+            .strings
             .get(prop.as_ref())
             .map(|v| v.as_number().unwrap_or(f64::NAN))
             .unwrap_or(f64::NAN),

package/crates/tish_builtins/src/construct.rs

@@ -1,12 +1,8 @@
 //! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
 //! Browser-exact behavior remains on `tish build --target js`.
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
-use std::rc::Rc;
 use std::sync::Arc;
-
-use tishlang_core::{ObjectMap, Value};
+use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";
 
@@ -16,7 +12,7 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
         Value::Function(f) => f(args),
         Value::Object(o) => {
             let b = o.borrow();
-            if let Some(Value::Function(ctor)) = b.get(&Arc::from(CONSTRUCT)) {
+            if let Some(Value::Function(ctor)) = b.strings.get(&Arc::from(CONSTRUCT)) {
                 let c = ctor.clone();
                 drop(b);
                 return c(args);
@@ -30,7 +26,7 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
 fn param(initial: f64) -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("value"), Value::Number(initial));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn connect_fn() -> Value {
@@ -45,21 +41,21 @@ fn audio_node_stub() -> Value {
     m.insert(Arc::from("frequency"), param(440.0));
     m.insert(Arc::from("Q"), param(1.0));
     m.insert(Arc::from("type"), Value::String("peaking".into()));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn analyser_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("fftSize"), Value::Number(2048.0));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn stereo_panner_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("pan"), param(0.0));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn audio_buffer_stub(len: usize) -> Value {
@@ -71,7 +67,7 @@ fn audio_buffer_stub(len: usize) -> Value {
         Arc::from("getChannelData"),
         Value::native(move |_args| Value::Array(data2.clone())),
     );
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn buffer_source_stub() -> Value {
@@ -79,12 +75,9 @@ fn buffer_source_stub() -> Value {
     m.insert(Arc::from("buffer"), Value::Null);
     m.insert(Arc::from("loop"), Value::Bool(false));
     m.insert(Arc::from("connect"), connect_fn());
-    m.insert(
-        Arc::from("start"),
-        Value::native(|_| Value::Null),
-    );
+    m.insert(Arc::from("start"), Value::native(|_| Value::Null));
     m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn oscillator_stub() -> Value {
@@ -92,12 +85,9 @@ fn oscillator_stub() -> Value {
     m.insert(Arc::from("frequency"), param(440.0));
     m.insert(Arc::from("type"), Value::String("sine".into()));
     m.insert(Arc::from("connect"), connect_fn());
-    m.insert(
-        Arc::from("start"),
-        Value::native(|_| Value::Null),
-    );
+    m.insert(Arc::from("start"), Value::native(|_| Value::Null));
     m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 fn audio_context_instance() -> Value {
@@ -140,12 +130,9 @@ fn audio_context_instance() -> Value {
         Arc::from("createOscillator"),
         Value::native(|_| oscillator_stub()),
     );
-    ctx.insert(
-        Arc::from("decodeAudioData"),
-        Value::native(|_| Value::Null),
-    );
+    ctx.insert(Arc::from("decodeAudioData"), Value::native(|_| Value::Null));
 
-    Value::Object(VmRef::new(ctx))
+    Value::object(ctx)
 }
 
 /// Global `Uint8Array` for native/VM: `new Uint8Array(n)` → numeric array of zeros (not real bytes).
@@ -160,7 +147,7 @@ pub fn uint8_array_constructor_value() -> Value {
     });
     let mut m = ObjectMap::default();
     m.insert(Arc::from(CONSTRUCT), ctor);
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }
 
 /// Global `AudioContext` for native/VM: stub graph (no real audio).
@@ -168,5 +155,5 @@ pub fn audio_context_constructor_value() -> Value {
     let ctor = Value::native(|_args: &[Value]| audio_context_instance());
     let mut m = ObjectMap::default();
     m.insert(Arc::from(CONSTRUCT), ctor);
-    Value::Object(VmRef::new(m))
+    Value::object(m)
 }

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/math.rs

@@ -80,3 +80,10 @@ pub fn hypot(args: &[Value]) -> Value {
     let y = extract_num(args.get(1)).unwrap_or(0.0);
     Value::Number(x.hypot(y))
 }
+
+/// ES6 `Math.imul`: 32-bit integer multiply (used by xmur3 PRNG in juke-cards).
+pub fn imul(args: &[Value]) -> Value {
+    let a = extract_num(args.first()).unwrap_or(0.0) as i32;
+    let b = extract_num(args.get(1)).unwrap_or(0.0) as i32;
+    Value::Number(a.wrapping_mul(b) as f64)
+}

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 {
@@ -191,6 +189,32 @@ pub fn substring(s: &Value, start: &Value, end: &Value) -> Value {
     }
 }
 
+/// JS `String.prototype.substr(start, length)`.
+pub fn substr(s: &Value, start: &Value, length: &Value) -> Value {
+    if let Value::String(s) = s {
+        let chars: Vec<char> = s.chars().collect();
+        let len = chars.len();
+        let mut start_idx = match start {
+            Value::Number(n) => *n as i64,
+            _ => 0,
+        };
+        if start_idx < 0 {
+            start_idx = (len as i64 + start_idx).max(0);
+        }
+        let start_idx = (start_idx as usize).min(len);
+        let count = match length {
+            Value::Null => len - start_idx,
+            Value::Number(n) => (*n as i64).max(0) as usize,
+            _ => len - start_idx,
+        };
+        let end_idx = (start_idx + count).min(len);
+        let result: String = chars[start_idx..end_idx].iter().collect();
+        Value::String(result.into())
+    } else {
+        Value::Null
+    }
+}
+
 pub fn split(s: &Value, sep: &Value) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {

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(_)));
+    }
+}