@tishlang/tish 2.10.1 → 2.16.13

package/crates/tish_builtins/src/collections.rs

@@ -54,38 +54,65 @@ impl PartialEq for Key {
 }
 impl Eq for Key {}
 
+/// The single source of truth for hashing a key `Value`. Both [`Key`] (owned, the stored key) and
+/// [`KeyRef`] (borrowed, the lookup probe) delegate here so an owned key and a borrowed probe of an
+/// equal value hash identically — the invariant that makes the zero-clone borrow lookup sound.
+#[inline]
+fn hash_key_value<H: Hasher>(v: &Value, state: &mut H) {
+    match v {
+        Value::Number(n) => {
+            0u8.hash(state);
+            // Canonicalize so `Eq` partners hash together: `+0` and `-0` share a key, and every
+            // NaN is one key.
+            let bits = if *n == 0.0 {
+                0u64
+            } else if n.is_nan() {
+                0x7ff8_0000_0000_0000
+            } else {
+                n.to_bits()
+            };
+            bits.hash(state);
+        }
+        Value::String(s) => {
+            1u8.hash(state);
+            s.as_str().hash(state);
+        }
+        Value::Bool(b) => {
+            2u8.hash(state);
+            b.hash(state);
+        }
+        Value::Null => 3u8.hash(state),
+        // Reference / identity values: per-variant tag only; `ptr_eq` in `Eq` does the rest.
+        Value::Symbol(_) => 4u8.hash(state),
+        Value::Array(_) => 5u8.hash(state),
+        Value::NumberArray(_) => 6u8.hash(state),
+        Value::Object(_) => 7u8.hash(state),
+        _ => 8u8.hash(state),
+    }
+}
+
 impl Hash for Key {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        match &self.0 {
-            Value::Number(n) => {
-                0u8.hash(state);
-                // Canonicalize so `Eq` partners hash together: `+0` and `-0` share a key, and every
-                // NaN is one key.
-                let bits = if *n == 0.0 {
-                    0u64
-                } else if n.is_nan() {
-                    0x7ff8_0000_0000_0000
-                } else {
-                    n.to_bits()
-                };
-                bits.hash(state);
-            }
-            Value::String(s) => {
-                1u8.hash(state);
-                s.as_str().hash(state);
-            }
-            Value::Bool(b) => {
-                2u8.hash(state);
-                b.hash(state);
-            }
-            Value::Null => 3u8.hash(state),
-            // Reference / identity values: per-variant tag only; `ptr_eq` in `Eq` does the rest.
-            Value::Symbol(_) => 4u8.hash(state),
-            Value::Array(_) => 5u8.hash(state),
-            Value::NumberArray(_) => 6u8.hash(state),
-            Value::Object(_) => 7u8.hash(state),
-            _ => 8u8.hash(state),
-        }
+        hash_key_value(&self.0, state);
+    }
+}
+
+/// Borrowed look-up probe for [`Key`]: wraps `&Value` so `get`/`contains_key`/`shift_remove` can
+/// query the store **without cloning the key into an owned `Key`** (no `Value` clone, no `Arc` bump).
+/// It hashes via [`hash_key_value`] (identical to `Key`) and compares via [`same_value_zero`]
+/// (identical to `Key`'s `Eq`), so it is `Equivalent<Key>` — the lookup is a drop-in for `&Key`.
+/// Only `set`/`add` (which must *store* the key) still build an owned `Key`.
+struct KeyRef<'a>(&'a Value);
+
+impl Hash for KeyRef<'_> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        hash_key_value(self.0, state);
+    }
+}
+
+impl indexmap::Equivalent<Key> for KeyRef<'_> {
+    fn equivalent(&self, key: &Key) -> bool {
+        same_value_zero(self.0, &key.0)
     }
 }
 
@@ -119,6 +146,53 @@ pub fn size_probe_len(op: &dyn TishOpaque) -> Option<f64> {
         .map(|p| p.0.borrow().len() as f64)
 }
 
+fn map_store(map: &Value) -> Option<Store> {
+    if let Value::Object(o) = map {
+        if let Some(Value::Opaque(op)) = o.borrow().strings.get(SIZE_SLOT) {
+            if let Some(probe) = op.as_ref().as_any().downcast_ref::<SizeProbe>() {
+                return Some(probe.0.clone());
+            }
+        }
+    }
+    None
+}
+
+/// Direct `Map.prototype.has` — skips bound-method `get_prop` + `value_call` (k-nucleotide hot path).
+/// Looks up via a borrowed [`KeyRef`]: no key clone, no owned `Key` allocation.
+pub fn map_has(map: &Value, key: &Value) -> Value {
+    match map_store(map) {
+        Some(s) => Value::Bool(s.borrow().contains_key(&KeyRef(key))),
+        None => Value::Bool(false),
+    }
+}
+
+/// Direct `Map.prototype.get`. Looks up via a borrowed [`KeyRef`] (no key clone / no owned `Key`).
+pub fn map_get(map: &Value, key: &Value) -> Value {
+    match map_store(map) {
+        Some(s) => s.borrow().get(&KeyRef(key)).cloned().unwrap_or(Value::Null),
+        None => Value::Null,
+    }
+}
+
+/// Direct `Map.prototype.set` (mutates in place; returns `undefined` = `Null`).
+pub fn map_set(map: &Value, key: Value, val: Value) -> Value {
+    if let Some(s) = map_store(map) {
+        s.borrow_mut().insert(Key(key), val);
+    }
+    Value::Null
+}
+
+/// Direct `Map.prototype.values` — snapshot iterator (same as the bound native method).
+pub fn map_values(map: &Value) -> Value {
+    match map_store(map) {
+        Some(s) => {
+            let out: Vec<Value> = s.borrow().values().cloned().collect();
+            crate::iterator::array_iterator(out)
+        }
+        None => crate::iterator::array_iterator(vec![]),
+    }
+}
+
 /// Wrap a backing store as the hidden [`SIZE_SLOT`] opaque. `Value::Opaque`'s payload is always
 /// `Arc<dyn TishOpaque>`, so on the single-threaded build (`Rc`-based `VmRef`) clippy's
 /// `arc_with_non_send_sync` fires spuriously — the `Arc` is mandated by the API, not a thread choice.
@@ -196,8 +270,8 @@ pub fn set_instance(initial: &[Value]) -> Value {
         m.insert(
             Arc::from("has"),
             Value::native(move |args: &[Value]| {
-                let v = args.first().cloned().unwrap_or(Value::Null);
-                Value::Bool(s.borrow().contains_key(&Key(v)))
+                let v = args.first().unwrap_or(&Value::Null);
+                Value::Bool(s.borrow().contains_key(&KeyRef(v)))
             }),
         );
     }
@@ -206,9 +280,9 @@ pub fn set_instance(initial: &[Value]) -> Value {
         m.insert(
             Arc::from("delete"),
             Value::native(move |args: &[Value]| {
-                let v = args.first().cloned().unwrap_or(Value::Null);
+                let v = args.first().unwrap_or(&Value::Null);
                 // `shift_remove` preserves iteration order (vs `swap_remove`).
-                Value::Bool(s.borrow_mut().shift_remove(&Key(v)).is_some())
+                Value::Bool(s.borrow_mut().shift_remove(&KeyRef(v)).is_some())
             }),
         );
     }
@@ -299,8 +373,8 @@ pub fn map_instance(pairs: &[Value]) -> Value {
         m.insert(
             Arc::from("get"),
             Value::native(move |args: &[Value]| {
-                let key = args.first().cloned().unwrap_or(Value::Null);
-                s.borrow().get(&Key(key)).cloned().unwrap_or(Value::Null)
+                let key = args.first().unwrap_or(&Value::Null);
+                s.borrow().get(&KeyRef(key)).cloned().unwrap_or(Value::Null)
             }),
         );
     }
@@ -309,8 +383,8 @@ pub fn map_instance(pairs: &[Value]) -> Value {
         m.insert(
             Arc::from("has"),
             Value::native(move |args: &[Value]| {
-                let key = args.first().cloned().unwrap_or(Value::Null);
-                Value::Bool(s.borrow().contains_key(&Key(key)))
+                let key = args.first().unwrap_or(&Value::Null);
+                Value::Bool(s.borrow().contains_key(&KeyRef(key)))
             }),
         );
     }
@@ -319,8 +393,8 @@ pub fn map_instance(pairs: &[Value]) -> Value {
         m.insert(
             Arc::from("delete"),
             Value::native(move |args: &[Value]| {
-                let key = args.first().cloned().unwrap_or(Value::Null);
-                Value::Bool(s.borrow_mut().shift_remove(&Key(key)).is_some())
+                let key = args.first().unwrap_or(&Value::Null);
+                Value::Bool(s.borrow_mut().shift_remove(&KeyRef(key)).is_some())
             }),
         );
     }

package/crates/tish_builtins/src/string.rs

@@ -4,9 +4,64 @@
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
 use crate::helpers::normalize_index;
+use std::cell::RefCell;
+use tishlang_core::ArcStr;
 use tishlang_core::Value;
 use tishlang_core::VmRef;
 
+// #203: a per-thread cursor cache that makes repeated character indexing (`charCodeAt(i)`, `s[i]`,
+// `charAt(i)`) O(1)/near-O(1) instead of O(i). tish strings are UTF-8, so `chars().nth(i)` scans from
+// the start — turning indexed/strided scans into O(n^2) (a strided checksum over a 1.3 MB string was
+// 4939ms vs node 1ms). For each recently-indexed string we cache whether it is all-ASCII (then a
+// character index equals a byte index → O(1) byte lookup) plus a forward cursor (so non-ASCII
+// sequential/strided scans advance from the last position, not from 0). Safety: the entry holds an
+// `ArcStr` CLONE, which keeps the backing allocation alive — so its data pointer can't be freed and
+// reused by another string while cached (no ABA), and since strings are immutable the cached ASCII
+// flag stays valid. Backends share this via `char_at_idx` (native + VM route through the builtin).
+// Semantics are unchanged: still character (Unicode scalar) indexing, identical to `chars().nth(i)`.
+struct CharCursor {
+    s: ArcStr,
+    ascii: bool,
+    /// Character (Unicode scalar) count, cached so `.length` is O(1) too — `for (i=0;i<s.length;i++)`
+    /// re-evaluates the bound every iteration, so an O(n) `chars().count()` there is itself O(n^2).
+    len_chars: usize,
+    char_idx: usize,
+    byte_off: usize,
+}
+
+thread_local! {
+    static INDEX_CURSOR: RefCell<Option<CharCursor>> = const { RefCell::new(None) };
+}
+
+/// Borrow the cursor entry for `s`, reseeding (compute ASCII flag + character count) if it currently
+/// caches a different backing allocation, then run `f` against it. Centralises the pointer-keyed
+/// reseed shared by [`char_at_idx`] and [`char_count`].
+fn with_cursor<R>(s: &ArcStr, f: impl FnOnce(&mut CharCursor, &ArcStr) -> R) -> R {
+    INDEX_CURSOR.with(|cell| {
+        let mut slot = cell.borrow_mut();
+        let hit = matches!(slot.as_ref(), Some(c)
+            if std::ptr::eq(c.s.as_bytes().as_ptr(), s.as_bytes().as_ptr()) && c.s.len() == s.len());
+        if !hit {
+            let ascii = s.as_bytes().is_ascii();
+            // ASCII → character count equals byte length (free); otherwise count once.
+            let len_chars = if ascii { s.len() } else { s.chars().count() };
+            *slot = Some(CharCursor {
+                s: s.clone(),
+                ascii,
+                len_chars,
+                char_idx: 0,
+                byte_off: 0,
+            });
+        }
+        f(slot.as_mut().unwrap(), s)
+    })
+}
+
+/// Character (Unicode scalar) count of `s`, O(1) after the first call on a given string.
+pub fn char_count(s: &ArcStr) -> usize {
+    with_cursor(s, |c, _| c.len_chars)
+}
+
 /// Byte offset -> character index.
 fn byte_to_char_index(s: &str, byte_offset: usize) -> usize {
     s.char_indices()
@@ -30,7 +85,7 @@ pub fn from_str(s: &str) -> Value {
 /// Get the length of a string (character count).
 pub fn len(s: &Value) -> Option<usize> {
     match s {
-        Value::String(str) => Some(str.chars().count()),
+        Value::String(str) => Some(char_count(str)),
         _ => None,
     }
 }
@@ -370,8 +425,38 @@ pub fn escape_html(s: &Value) -> Value {
     Value::String(tishlang_core::ArcStr::from(out))
 }
 
-fn char_at_idx(s: &str, idx: usize) -> Option<char> {
-    s.chars().nth(idx)
+/// Character (Unicode scalar) at index `idx`, using the cursor cache (see [`CharCursor`]).
+/// Equivalent to `s.chars().nth(idx)` but O(1) for ASCII strings and near-O(1) for forward/strided
+/// scans of non-ASCII strings, instead of O(idx) every call.
+fn char_at_idx(s: &ArcStr, idx: usize) -> Option<char> {
+    with_cursor(s, |c, s| {
+        if c.ascii {
+            // ASCII: character index == byte index, and every byte is its own scalar.
+            return s.as_bytes().get(idx).map(|&b| b as char);
+        }
+        // Non-ASCII: advance from the nearest known position (forward fast path); restart from 0 only
+        // when indexing backwards relative to the cursor.
+        let (base_idx, base_off) = if idx >= c.char_idx {
+            (c.char_idx, c.byte_off)
+        } else {
+            (0, 0)
+        };
+        match s[base_off..].char_indices().nth(idx - base_idx) {
+            Some((rel_off, ch)) => {
+                c.char_idx = idx;
+                c.byte_off = base_off + rel_off;
+                Some(ch)
+            }
+            None => None,
+        }
+    })
+}
+
+/// Character (Unicode scalar) at index `idx` via the cursor cache — the O(1)/near-O(1) primitive
+/// behind `s[i]`. Returns `None` for an out-of-range index; each backend maps that to its own
+/// out-of-bounds behaviour (interpreter/native → null, VM → error).
+pub fn nth_char(s: &ArcStr, idx: usize) -> Option<char> {
+    char_at_idx(s, idx)
 }
 
 pub fn char_at(s: &Value, idx: &Value) -> Value {
@@ -396,11 +481,13 @@ pub fn at(s: &Value, index: &Value) -> Value {
             Value::Number(n) => *n as i64,
             _ => 0,
         };
-        let chars: Vec<char> = s.chars().collect();
-        let len = chars.len() as i64;
-        let idx = if i < 0 { len + i } else { i };
-        if idx >= 0 && idx < len {
-            return Value::String(chars[idx as usize].to_string().into());
+        // Non-negative indices use the cursor cache directly; a negative index counts from the end,
+        // which needs the character length first (inherently O(n)).
+        let idx = if i < 0 { s.chars().count() as i64 + i } else { i };
+        if idx >= 0 {
+            if let Some(c) = char_at_idx(s, idx as usize) {
+                return Value::String(c.to_string().into());
+            }
         }
     }
     Value::Null

package/crates/tish_bytecode/src/chunk.rs

@@ -79,6 +79,12 @@ pub struct Chunk {
     pub lines: Vec<(u32, u32)>,
     /// Source file path for error messages (`file:line`); propagated to nested chunks. Runtime-only.
     pub source: Option<Arc<str>>,
+    /// #187: when `Some(name)`, this chunk is a top-level `function name` whose binding is provably
+    /// stable across the whole program (never reassigned/shadowed/redeclared). The numeric JIT
+    /// registers such a chunk under `name` so a caller's `name(args)` can lower to a direct native
+    /// call. `None` for anonymous/nested/unstable functions. Runtime-only; not serialized (a reloaded
+    /// program just forgoes the cross-function-call optimization).
+    pub global_name: Option<Arc<str>>,
 }
 
 impl Chunk {
@@ -95,6 +101,7 @@ impl Chunk {
             inline_caches: InlineCaches::default(),
             lines: Vec::new(),
             source: None,
+            global_name: None,
         }
     }