@tishlang/tish-lsp 2.12.0 → 2.35.0

package/crates/tish_builtins/src/number.rs

@@ -43,6 +43,179 @@ pub fn to_fixed_str(num: f64, digits: usize) -> String {
     format!("{:.*}", digits, rounded)
 }
 
+/// `Number.prototype.toExponential(fractionDigits?)` — ECMA-262 §21.1.3.2. Exponential notation with
+/// `fractionDigits` mantissa fraction digits (0–100), or the minimal digits needed when omitted. The
+/// exponent always carries an explicit sign (`1.23e+4`, `1e-7`) to match V8.
+pub fn to_exponential(n: &Value, digits: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    let d = match digits {
+        Value::Number(x) => Some((*x as i32).clamp(0, 100) as usize),
+        _ => None,
+    };
+    Value::String(to_exponential_str(num, d).into())
+}
+
+/// f64-domain core of `toExponential`, shared with the tree-walk interpreter.
+pub fn to_exponential_str(num: f64, digits: Option<usize>) -> String {
+    if num.is_nan() {
+        return "NaN".to_string();
+    }
+    if num.is_infinite() {
+        return if num < 0.0 { "-Infinity" } else { "Infinity" }.to_string();
+    }
+    let d = match digits {
+        // No fractionDigits: shortest round-trip mantissa (Rust's `{:e}` matches V8 here).
+        None => return fix_exponent_sign(&format!("{:e}", num)),
+        Some(d) => d,
+    };
+    if num == 0.0 {
+        let mant = if d == 0 {
+            "0".to_string()
+        } else {
+            format!("0.{}", "0".repeat(d))
+        };
+        return format!("{}e+0", mant);
+    }
+    let sign = if num < 0.0 { "-" } else { "" };
+    let (ds, e) = sig_digits(num.abs(), d + 1);
+    let mant = if d == 0 {
+        ds
+    } else {
+        format!("{}.{}", &ds[..1], &ds[1..])
+    };
+    let esign = if e >= 0 { "+" } else { "-" };
+    format!("{}{}e{}{}", sign, mant, esign, e.abs())
+}
+
+/// Round `x` (finite, `x > 0`) to `sig` significant decimal digits with **half-away-from-zero**
+/// rounding — ECMA's "pick the larger n" tie rule (`2.5.toPrecision(1) === "3"`, not "2"). Returns the
+/// `sig`-digit string and the base-10 exponent of the leading digit.
+///
+/// The exact value of an f64 has a finite decimal expansion; scaling it through `f64` arithmetic
+/// re-rounds and can land a genuinely-below-half value (e.g. `2.675` ≈ `2.67499…`) exactly on `.5`,
+/// corrupting the tie test. So we format with many guard digits — `{:.Ne}` gives the correctly-rounded
+/// exact-value expansion — capturing the TRUE digit at position `sig`, then round the digit string:
+/// `digit[sig] >= 5` rounds up (half-away; `== 5` is a true tie only because the guard digits show no
+/// nonzero remainder). Rust's `{:e}` alone rounds half-to-even, which is exactly what we must avoid.
+fn sig_digits(x: f64, sig: usize) -> (String, i32) {
+    let sig = sig.max(1);
+    // Guard digits push the format's own (half-to-even) rounding far to the right of digit[sig], so
+    // digit[sig] is exact. A cascade into digit[sig] would need 16 consecutive 9s — not a real input.
+    let guard = sig + 16;
+    let raw = format!("{:.*e}", guard, x);
+    let (mant, exp_str) = raw.split_once('e').unwrap();
+    let mut e: i32 = exp_str.parse().unwrap_or(0);
+    let mut digits: Vec<u8> = mant
+        .bytes()
+        .filter(u8::is_ascii_digit)
+        .map(|b| b - b'0')
+        .collect();
+    if digits.len() > sig {
+        let round_up = digits[sig] >= 5;
+        digits.truncate(sig);
+        if round_up {
+            let mut i = sig;
+            loop {
+                if i == 0 {
+                    // carry out of the leading digit: 9…9 → 1 0…0, one more place
+                    digits.insert(0, 1);
+                    digits.truncate(sig);
+                    e += 1;
+                    break;
+                }
+                i -= 1;
+                if digits[i] == 9 {
+                    digits[i] = 0;
+                } else {
+                    digits[i] += 1;
+                    break;
+                }
+            }
+        }
+    }
+    let s: String = digits.iter().map(|d| (d + b'0') as char).collect();
+    (s, e)
+}
+
+/// Rust's `{:e}` writes a bare positive exponent (`1.23e4`); JS/V8 always signs it (`1.23e+4`). Negative
+/// exponents already carry `-`.
+fn fix_exponent_sign(s: &str) -> String {
+    match s.split_once('e') {
+        Some((mantissa, exp)) if !exp.starts_with('-') && !exp.starts_with('+') => {
+            format!("{}e+{}", mantissa, exp)
+        }
+        _ => s.to_string(),
+    }
+}
+
+/// `Number.prototype.toPrecision(precision?)` — ECMA-262 §21.1.3.5. With `precision` significant digits,
+/// choosing fixed or exponential per the spec; omitted precision falls back to `ToString`. An
+/// out-of-range precision (`<1` or `>100`) parks a catchable `RangeError`.
+pub fn to_precision(n: &Value, precision: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    match precision {
+        Value::Number(p) => {
+            let p = *p as i32;
+            if !(1..=100).contains(&p) && num.is_finite() {
+                tishlang_core::set_pending_throw(tishlang_core::range_error(
+                    "toPrecision() argument must be between 1 and 100",
+                ));
+                return Value::Null;
+            }
+            Value::String(to_precision_str(num, p).into())
+        }
+        // precision undefined → behave like ToString(number)
+        _ => Value::String(tishlang_core::js_number_to_string(num).into()),
+    }
+}
+
+/// f64-domain core of `toPrecision`, shared with the tree-walk interpreter. Assumes `precision` is in
+/// range (the `&Value` entry point validates and parks a RangeError otherwise).
+pub fn to_precision_str(num: f64, precision: i32) -> String {
+    if num.is_nan() {
+        return "NaN".to_string();
+    }
+    if num.is_infinite() {
+        return if num < 0.0 { "-Infinity" } else { "Infinity" }.to_string();
+    }
+    let p = precision.clamp(1, 100) as usize;
+    if num == 0.0 {
+        if p == 1 {
+            return "0".to_string();
+        }
+        return format!("0.{}", "0".repeat(p - 1));
+    }
+    let sign = if num < 0.0 { "-" } else { "" };
+    // `p` significant digits + base-10 exponent, half-away rounded (shared with toExponential).
+    let (digits, e) = sig_digits(num.abs(), p);
+    let body = if e < -6 || e >= p as i32 {
+        // exponential form
+        let mut m = String::new();
+        m.push(digits.as_bytes()[0] as char);
+        if p > 1 {
+            m.push('.');
+            m.push_str(&digits[1..]);
+        }
+        let esign = if e >= 0 { "+" } else { "-" };
+        format!("{}e{}{}", m, esign, e.abs())
+    } else if e == p as i32 - 1 {
+        digits
+    } else if e >= 0 {
+        let split = (e + 1) as usize;
+        format!("{}.{}", &digits[..split], &digits[split..])
+    } else {
+        let zeros = (-e - 1) as usize;
+        format!("0.{}{}", "0".repeat(zeros), digits)
+    };
+    format!("{}{}", sign, body)
+}
+
 /// `Number.prototype.toString([radix])` — ECMA-262 §21.1.3.6.
 ///
 /// Radix defaults to 10 (canonical JS number formatting). For radix 2–36 the value is

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,
     }
 }
@@ -262,6 +317,59 @@ pub fn trim(s: &Value) -> Value {
     }
 }
 
+pub fn trim_start(s: &Value) -> Value {
+    if let Value::String(s) = s {
+        Value::String(s.trim_start().into())
+    } else {
+        Value::Null
+    }
+}
+
+/// Pure `String.prototype.normalize` core (ECMA-262 §22.1.3.13). `form` is one of NFC/NFD/NFKC/NFKD;
+/// returns `None` for an unrecognized form so the caller can surface a `RangeError`. Shared by every
+/// backend so interp/vm/native stay byte-identical.
+pub fn normalize_form(s: &str, form: &str) -> Option<String> {
+    use unicode_normalization::UnicodeNormalization;
+    match form {
+        "NFC" => Some(s.nfc().collect()),
+        "NFD" => Some(s.nfd().collect()),
+        "NFKC" => Some(s.nfkc().collect()),
+        "NFKD" => Some(s.nfkd().collect()),
+        _ => None,
+    }
+}
+
+/// `String.prototype.normalize(form?)` — core-`Value` entry (vm/native). An omitted form defaults to
+/// NFC; an invalid form parks a catchable `RangeError`.
+pub fn normalize(s: &Value, form: &Value) -> Value {
+    let input = match s {
+        Value::String(s) => s.as_ref(),
+        _ => return Value::Null,
+    };
+    let f: String = match form {
+        Value::Null => "NFC".to_string(),
+        Value::String(f) => f.to_string(),
+        v => v.to_display_string(),
+    };
+    match normalize_form(input, &f) {
+        Some(out) => Value::String(out.into()),
+        None => {
+            tishlang_core::set_pending_throw(tishlang_core::range_error(
+                "The normalization form should be one of NFC, NFD, NFKC, NFKD.",
+            ));
+            Value::Null
+        }
+    }
+}
+
+pub fn trim_end(s: &Value) -> Value {
+    if let Value::String(s) = s {
+        Value::String(s.trim_end().into())
+    } else {
+        Value::Null
+    }
+}
+
 pub fn to_upper_case(s: &Value) -> Value {
     if let Value::String(s) = s {
         Value::String(s.to_uppercase().into())
@@ -278,22 +386,74 @@ pub fn to_lower_case(s: &Value) -> Value {
     }
 }
 
-pub fn starts_with(s: &Value, search: &Value) -> Value {
+pub fn starts_with(s: &Value, search: &Value, position: Option<&Value>) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
-        Value::Bool(s.starts_with(search.as_str()))
+        // `position`: test as if the string began at char `position` (clamped to [0, len]). Absent → 0.
+        let pos = match position {
+            Some(Value::Number(n)) if *n > 0.0 => *n as usize,
+            _ => 0,
+        };
+        let byte_start = s.char_indices().nth(pos).map(|(b, _)| b).unwrap_or(s.len());
+        Value::Bool(s[byte_start..].starts_with(search.as_str()))
     } else {
         Value::Bool(false)
     }
 }
 
-pub fn ends_with(s: &Value, search: &Value) -> Value {
+pub fn ends_with(s: &Value, search: &Value, end_position: Option<&Value>) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
-        Value::Bool(s.ends_with(search.as_str()))
+        // `endPosition`: test as if the string ended at char `endPosition` (clamped to [0, len]).
+        // Absent → the full length.
+        let char_count = s.chars().count();
+        let end = match end_position {
+            Some(Value::Number(n)) if *n >= 0.0 => (*n as usize).min(char_count),
+            Some(Value::Number(_)) => 0,
+            _ => char_count,
+        };
+        let byte_end = s.char_indices().nth(end).map(|(b, _)| b).unwrap_or(s.len());
+        Value::Bool(s[..byte_end].ends_with(search.as_str()))
     } else {
         Value::Bool(false)
     }
 }
 
+/// Expand a string replacement's `$` patterns for one match: `$$`→`$`, `$&`→the match, `` $` ``→the
+/// text before it, `$'`→the text after it. Any other `$x` is literal. (String-search `replace`; the
+/// numbered `$1` captures only apply to regex replacements.)
+pub fn expand_replacement(repl: &str, matched: &str, before: &str, after: &str) -> String {
+    if !repl.contains('$') {
+        return repl.to_string();
+    }
+    let mut out = String::with_capacity(repl.len());
+    let mut chars = repl.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '$' {
+            match chars.peek() {
+                Some('$') => {
+                    out.push('$');
+                    chars.next();
+                }
+                Some('&') => {
+                    out.push_str(matched);
+                    chars.next();
+                }
+                Some('`') => {
+                    out.push_str(before);
+                    chars.next();
+                }
+                Some('\'') => {
+                    out.push_str(after);
+                    chars.next();
+                }
+                _ => out.push('$'),
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
 fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Value {
     if let Value::String(s) = s {
         let search_str = match search {
@@ -304,12 +464,37 @@ fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Va
             Value::String(ss) => ss.as_str(),
             _ => "",
         };
-        let result = if all {
-            s.replace(search_str, repl_str)
-        } else {
-            s.replacen(search_str, repl_str, 1)
-        };
-        Value::String(result.into())
+        // Fast path: no `$` in the replacement (and non-empty search) → the library replace.
+        if !repl_str.contains('$') || search_str.is_empty() {
+            let result = if all {
+                s.replace(search_str, repl_str)
+            } else {
+                s.replacen(search_str, repl_str, 1)
+            };
+            return Value::String(result.into());
+        }
+        // `$`-expansion path: expand per match against the original string's before/after context.
+        let sref = s.as_str();
+        let mut out = String::with_capacity(sref.len());
+        let mut last = 0usize;
+        let mut start = 0usize;
+        while let Some(pos) = sref[start..].find(search_str) {
+            let m = start + pos;
+            out.push_str(&sref[last..m]);
+            out.push_str(&expand_replacement(
+                repl_str,
+                search_str,
+                &sref[..m],
+                &sref[m + search_str.len()..],
+            ));
+            last = m + search_str.len();
+            start = last;
+            if !all {
+                break;
+            }
+        }
+        out.push_str(&sref[last..]);
+        Value::String(out.into())
     } else {
         Value::Null
     }
@@ -370,8 +555,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 +611,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
@@ -420,6 +637,23 @@ pub fn char_code_at(s: &Value, idx: &Value) -> Value {
     }
 }
 
+/// `codePointAt(i)` — the Unicode code point at char index `i`, or `null` (JS `undefined`) if out of
+/// range. tish strings are code-point sequences, so this returns the same value as `charCodeAt` for
+/// an in-range index, but reads `null` (not `NaN`) past the end.
+pub fn code_point_at(s: &Value, idx: &Value) -> Value {
+    if let Value::String(s) = s {
+        let idx = match idx {
+            Value::Number(n) if *n >= 0.0 => *n as usize,
+            _ => return Value::Null,
+        };
+        char_at_idx(s, idx)
+            .map(|c| Value::Number(c as u32 as f64))
+            .unwrap_or(Value::Null)
+    } else {
+        Value::Null
+    }
+}
+
 pub fn repeat(s: &Value, count: &Value) -> Value {
     if let Value::String(s) = s {
         let count = match count {
@@ -438,12 +672,15 @@ fn pad_impl(s: &Value, target_len: &Value, pad: &Value, at_start: bool) -> Value
             Value::Number(n) => *n as usize,
             _ => return Value::String(s.clone()),
         };
+        // An *explicit* empty fill string means "no padding" (spec: `padStart(n, "")` → original,
+        // unchanged); only an ABSENT pad arg (`Value::Null`) defaults to a space. The old
+        // `if !p.is_empty()` guard conflated the two, space-padding on an explicit `""`.
         let pad_str = match pad {
-            Value::String(p) if !p.is_empty() => p.as_str(),
+            Value::String(p) => p.as_str(),
             _ => " ",
         };
         let char_count = s.chars().count();
-        if char_count >= target_len {
+        if char_count >= target_len || pad_str.is_empty() {
             return Value::String(s.clone());
         }
         let needed = target_len - char_count;
@@ -609,9 +846,12 @@ mod tests {
     fn case_and_prefix_suffix() {
         assert_same!(to_upper_case(&s("aB")), s("AB"));
         assert_same!(to_lower_case(&s("aB")), s("ab"));
-        assert_same!(starts_with(&s("/api"), &s("/api")), Value::Bool(true));
-        assert_same!(ends_with(&s("x.js"), &s(".js")), Value::Bool(true));
-        assert_same!(starts_with(&n(1.0), &s("")), Value::Bool(false));
+        assert_same!(starts_with(&s("/api"), &s("/api"), None), Value::Bool(true));
+        assert_same!(ends_with(&s("x.js"), &s(".js"), None), Value::Bool(true));
+        assert_same!(starts_with(&n(1.0), &s(""), None), Value::Bool(false));
+        // 2nd-arg: position / endPosition.
+        assert_same!(starts_with(&s("abc"), &s("bc"), Some(&n(1.0))), Value::Bool(true));
+        assert_same!(ends_with(&s("abc"), &s("ab"), Some(&n(2.0))), Value::Bool(true));
     }
 
     #[test]

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,
         }
     }