@tishlang/tish-lsp 2.16.13 → 2.35.0

package/crates/tish_builtins/src/string.rs

@@ -317,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())
@@ -333,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 {
@@ -359,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
     }
@@ -507,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 {
@@ -525,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;
@@ -696,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/compiler.rs

@@ -334,10 +334,16 @@ fn stmt_rebinds(s: &Statement, name: &str) -> bool {
         }
         Statement::ForOf {
             name: n,
-            iterable,
+            iterable: e,
             body,
             ..
-        } => n.as_ref() == name || expr_rebinds(iterable, name) || stmt_rebinds(body, name),
+        }
+        | Statement::ForIn {
+            name: n,
+            object: e,
+            body,
+            ..
+        } => n.as_ref() == name || expr_rebinds(e, name) || stmt_rebinds(body, name),
         Statement::Switch {
             expr,
             cases,
@@ -504,10 +510,16 @@ fn name_rebinds_in_stmt(s: &Statement, name: &str) -> bool {
         }
         Statement::ForOf {
             name: n,
-            iterable,
+            iterable: e,
             body,
             ..
-        } => n.as_ref() == name || expr_rebinds(iterable, name) || name_rebinds_in_stmt(body, name),
+        }
+        | Statement::ForIn {
+            name: n,
+            object: e,
+            body,
+            ..
+        } => n.as_ref() == name || expr_rebinds(e, name) || name_rebinds_in_stmt(body, name),
         Statement::Switch {
             expr,
             cases,
@@ -1803,6 +1815,46 @@ impl<'a> Compiler<'a> {
                 self.emit(Opcode::LoopVarsEnd);
                 self.exit_block_scope();
             }
+            Statement::ForIn {
+                name,
+                name_span,
+                object,
+                body,
+                span,
+            } => {
+                // Lower `for (let k in obj)` to `for (let k of Object.keys(obj))` (#413): Object.keys
+                // yields exactly the own enumerable keys the interpreter enumerates — insertion order
+                // for objects, index strings for arrays, and `[]` for a non-object (so `for (k in
+                // null)` no-ops). Reuses the whole for-of iteration path.
+                let dummy = Span {
+                    start: (0, 0),
+                    end: (0, 0),
+                };
+                let keys_call = Expr::Call {
+                    callee: Box::new(Expr::Member {
+                        object: Box::new(Expr::Ident {
+                            name: Arc::from("Object"),
+                            span: dummy,
+                        }),
+                        prop: MemberProp::Name {
+                            name: Arc::from("keys"),
+                            span: dummy,
+                        },
+                        optional: false,
+                        span: dummy,
+                    }),
+                    args: vec![CallArg::Expr(object.clone())],
+                    span: dummy,
+                };
+                let lowered = Statement::ForOf {
+                    name: Arc::clone(name),
+                    name_span: *name_span,
+                    iterable: keys_call,
+                    body: body.clone(),
+                    span: *span,
+                };
+                self.compile_statement(&lowered)?;
+            }
             Statement::Return { value, .. } => {
                 // Evaluate the return value first (JS order), then run any enclosing `finally`
                 // blocks (they're stack-neutral, so the value stays on top), then return.

package/crates/tish_bytecode/src/opcode.rs

@@ -258,7 +258,9 @@ impl MathUnaryFn {
                 }
             }
             MathUnaryFn::Trunc => x.trunc(),
-            // JS `Math.sign` (matches `tishlang_builtins::math::sign`): NaN→NaN, else ±1, and 0/-0→+0.
+            // JS `Math.sign` (matches `tishlang_builtins::math::sign`): NaN→NaN, else ±1; and for
+            // ±0 return `x` unchanged so `Math.sign(-0)` is `-0` (`x < 0.0` is false for -0, so it
+            // lands in the else — bare `0.0` would drop the sign).
             MathUnaryFn::Sign => {
                 if x.is_nan() {
                     f64::NAN
@@ -267,7 +269,7 @@ impl MathUnaryFn {
                 } else if x < 0.0 {
                     -1.0
                 } else {
-                    0.0
+                    x
                 }
             }
             MathUnaryFn::Sin => x.sin(),