@tishlang/tish-lsp 2.16.13 → 2.36.0

package/crates/tish_runtime/src/lib.rs

@@ -118,18 +118,23 @@ pub use tishlang_builtins::array::{
     find_last_index as array_find_last_index, flat as array_flat_impl, flat_map as array_flat_map,
     for_each as array_for_each, includes as array_includes_impl, index_of as array_index_of_impl,
     join as array_join_impl, map as array_map, pop as array_pop, push as array_push_impl,
-    fill as array_fill, reduce as array_reduce, reverse as array_reverse, shift as array_shift,
+    fill as array_fill, last_index_of as array_last_index_of, copy_within as array_copy_within,
+    reduce as array_reduce, reduce_right as array_reduce_right, reverse as array_reverse,
+    keys as array_keys, values as array_values, entries as array_entries, shift as array_shift,
     shuffle as array_shuffle, slice as array_slice_impl, snapshot_values as array_snapshot_values,
     as_f64_snapshot as array_as_f64_snapshot, some as array_some,
     sort_by_keys as array_sort_by_keys, sort_default as array_sort_default,
     sort_numeric_asc as array_sort_numeric_asc, sort_numeric_desc as array_sort_numeric_desc,
     sort_with_comparator as array_sort_with_comparator, splice as array_splice_impl,
+    to_reversed as array_to_reversed, to_sorted as array_to_sorted,
+    to_spliced as array_to_spliced, with as array_with,
     unshift as array_unshift_impl,
 };
 
 // Re-export string methods from tishlang_builtins
 pub use tishlang_builtins::string::{
     at as string_at_impl, char_at as string_char_at_impl, char_code_at as string_char_code_at_impl,
+    code_point_at as string_code_point_at,
     ends_with as string_ends_with_impl, escape_html as string_escape_html_impl,
     includes as string_includes_impl, index_of as string_index_of_impl,
     last_index_of as string_last_index_of_impl, pad_end as string_pad_end_impl,
@@ -138,8 +143,9 @@ pub use tishlang_builtins::string::{
     slice as string_slice_impl, split as string_split_impl, split_limit as string_split_limit_impl,
     starts_with as string_starts_with_impl, substr as string_substr_impl,
     substring as string_substring_impl,
-    to_lower_case as string_to_lower_case, to_upper_case as string_to_upper_case,
-    trim as string_trim,
+    normalize as string_normalize, to_lower_case as string_to_lower_case,
+    to_upper_case as string_to_upper_case, trim as string_trim, trim_end as string_trim_end,
+    trim_start as string_trim_start,
 };
 
 // Wrapper functions to maintain API compatibility
@@ -149,8 +155,8 @@ pub fn array_push(arr: &Value, args: &[Value]) -> Value {
 pub fn array_unshift(arr: &Value, args: &[Value]) -> Value {
     array_unshift_impl(arr, args)
 }
-pub fn array_index_of(arr: &Value, search: &Value) -> Value {
-    array_index_of_impl(arr, search)
+pub fn array_index_of(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
+    array_index_of_impl(arr, search, from)
 }
 pub fn array_includes(arr: &Value, search: &Value, from: &Value) -> Value {
     array_includes_impl(arr, search, Some(from))
@@ -217,11 +223,11 @@ pub fn string_split_limit(s: &Value, sep: &Value, limit: &Value) -> Value {
     }
     string_split_limit_impl(s, sep, max)
 }
-pub fn string_starts_with(s: &Value, search: &Value) -> Value {
-    string_starts_with_impl(s, search)
+pub fn string_starts_with(s: &Value, search: &Value, position: Option<&Value>) -> Value {
+    string_starts_with_impl(s, search, position)
 }
-pub fn string_ends_with(s: &Value, search: &Value) -> Value {
-    string_ends_with_impl(s, search)
+pub fn string_ends_with(s: &Value, search: &Value, end_position: Option<&Value>) -> Value {
+    string_ends_with_impl(s, search, end_position)
 }
 pub fn string_replace(s: &Value, search: &Value, replacement: &Value) -> Value {
     #[cfg(feature = "regex")]
@@ -391,6 +397,12 @@ pub fn string_last_index_of(s: &Value, search: &Value, position: &Value) -> Valu
 pub fn number_to_fixed(n: &Value, digits: &Value) -> Value {
     tishlang_builtins::number::to_fixed(n, digits)
 }
+pub fn number_to_exponential(n: &Value, digits: &Value) -> Value {
+    tishlang_builtins::number::to_exponential(n, digits)
+}
+pub fn number_to_precision(n: &Value, precision: &Value) -> Value {
+    tishlang_builtins::number::to_precision(n, precision)
+}
 
 /// `.toString([radix])` for the compiled backend (issue #59). A number receiver uses the
 /// shared radix formatter so it stays byte-identical with the VM / interpreter; any other
@@ -800,6 +812,15 @@ pub fn decode_uri(args: &[Value]) -> Value {
 pub fn encode_uri(args: &[Value]) -> Value {
     builtins_encode_uri(args)
 }
+pub fn encode_uri_component(args: &[Value]) -> Value {
+    tishlang_builtins::globals::encode_uri_component(args)
+}
+pub fn decode_uri_component(args: &[Value]) -> Value {
+    tishlang_builtins::globals::decode_uri_component(args)
+}
+pub fn structured_clone(args: &[Value]) -> Value {
+    tishlang_builtins::globals::structured_clone(args)
+}
 
 // Math functions - use tishlang_builtins::math
 pub use tishlang_builtins::math::{
@@ -903,6 +924,14 @@ runtime_math_unary!(math_atanh, atanh);
 runtime_math_unary!(math_cbrt, cbrt);
 runtime_math_unary!(math_log2, log2);
 runtime_math_unary!(math_log10, log10);
+runtime_math_unary!(math_expm1, exp_m1);
+runtime_math_unary!(math_log1p, ln_1p);
+pub fn math_clz32(args: &[Value]) -> Value {
+    tishlang_builtins::math::clz32(args)
+}
+pub fn math_fround(args: &[Value]) -> Value {
+    tishlang_builtins::math::fround(args)
+}
 
 pub fn json_stringify(args: &[Value]) -> Value {
     let v = args.first().cloned().unwrap_or(Value::Null);
@@ -921,6 +950,18 @@ pub fn json_parse(args: &[Value]) -> Value {
 pub fn array_is_array(args: &[Value]) -> Value {
     builtins_array_is_array(args)
 }
+pub fn array_of(args: &[Value]) -> Value {
+    tishlang_builtins::globals::array_of(args)
+}
+pub fn array_from(args: &[Value]) -> Value {
+    tishlang_builtins::globals::array_from(args)
+}
+pub fn object_is(args: &[Value]) -> Value {
+    tishlang_builtins::globals::object_is(args)
+}
+pub fn object_has_own(args: &[Value]) -> Value {
+    tishlang_builtins::globals::object_has_own(args)
+}
 
 pub fn string_from_char_code(args: &[Value]) -> Value {
     builtins_string_from_char_code(args)
@@ -935,6 +976,18 @@ pub fn string_convert(args: &[Value]) -> Value {
 pub fn number_convert(args: &[Value]) -> Value {
     builtins_number_convert(args)
 }
+pub fn number_is_integer(args: &[Value]) -> Value {
+    tishlang_builtins::globals::number_is_integer(args)
+}
+pub fn number_is_safe_integer(args: &[Value]) -> Value {
+    tishlang_builtins::globals::number_is_safe_integer(args)
+}
+pub fn number_is_nan(args: &[Value]) -> Value {
+    tishlang_builtins::globals::number_is_nan(args)
+}
+pub fn number_is_finite(args: &[Value]) -> Value {
+    tishlang_builtins::globals::number_is_finite(args)
+}
 
 #[cfg(feature = "process")]
 pub fn process_exit(args: &[Value]) -> Value {
@@ -996,9 +1049,75 @@ pub fn process_exec_file(args: &[Value]) -> Value {
     }
 }
 
+/// Build the `{ code: number, stdout: string, stderr: string }` capture object (#475). stdout/stderr
+/// are lossy-UTF-8 decoded, matching the `fs` string convention (invalid bytes → replacement chars,
+/// never dropped output).
+#[cfg(feature = "process")]
+fn process_capture_obj(code: i32, stdout: String, stderr: String) -> Value {
+    let mut m = tishlang_core::ObjectMap::default();
+    m.insert("code".into(), Value::Number(code as f64));
+    m.insert("stdout".into(), Value::String(stdout.into()));
+    m.insert("stderr".into(), Value::String(stderr.into()));
+    Value::object(m)
+}
+
+/// Build the capture object from a `Command::output()` result. `code` is the exit status, or `-1`
+/// when the process was killed by a signal or failed to spawn (spawn failure puts the OS error in
+/// `stderr`).
+#[cfg(feature = "process")]
+fn process_capture_result(out: std::io::Result<std::process::Output>) -> Value {
+    match out {
+        Ok(o) => process_capture_obj(
+            o.status.code().unwrap_or(-1),
+            String::from_utf8_lossy(&o.stdout).into_owned(),
+            String::from_utf8_lossy(&o.stderr).into_owned(),
+        ),
+        Err(e) => process_capture_obj(-1, String::new(), e.to_string()),
+    }
+}
+
+/// `process.execCapture(cmd)` — run `sh -c cmd` and CAPTURE its output as
+/// `{ code: number, stdout: string, stderr: string }` (Rust `Command::output`; Node
+/// `execSync`/`spawnSync({ encoding })`). Use `execFileCapture` for untrusted arguments — this shell
+/// form interprets metacharacters.
+#[cfg(feature = "process")]
+pub fn process_exec_capture(args: &[Value]) -> Value {
+    use std::process::Command;
+    let cmd = args
+        .first()
+        .map(|v| v.to_display_string())
+        .unwrap_or_default();
+    if cmd.is_empty() {
+        return process_capture_obj(0, String::new(), String::new());
+    }
+    process_capture_result(Command::new("sh").arg("-c").arg(&cmd).output())
+}
+
+/// `process.execFileCapture(program, [args])` — run a program directly, WITHOUT a shell, capturing
+/// output as `{ code, stdout, stderr }`. Arguments are passed verbatim, so shell metacharacters in
+/// untrusted data are never interpreted — the safe capturing counterpart for input-derived args
+/// (#384, #475). This is the primitive for shelling out to a CLI and reading its output (e.g.
+/// `git status --porcelain`).
+#[cfg(feature = "process")]
+pub fn process_exec_file_capture(args: &[Value]) -> Value {
+    use std::process::Command;
+    let program = args
+        .first()
+        .map(|v| v.to_display_string())
+        .unwrap_or_default();
+    if program.is_empty() {
+        return process_capture_obj(0, String::new(), String::new());
+    }
+    let argv: Vec<String> = match args.get(1) {
+        Some(Value::Array(a)) => a.borrow().iter().map(|v| v.to_display_string()).collect(),
+        _ => Vec::new(),
+    };
+    process_capture_result(Command::new(&program).args(&argv).output())
+}
+
 #[cfg(all(test, feature = "process", unix))]
 mod execfile_tests_384 {
-    use super::process_exec_file;
+    use super::{process_exec_file, process_exec_file_capture};
     use tishlang_core::{Value, VmRef};
 
     #[test]
@@ -1012,6 +1131,47 @@ mod execfile_tests_384 {
         // empty program is a no-op returning 0, matching `exec`.
         assert!(matches!(process_exec_file(&[]), Value::Number(n) if n == 0.0));
     }
+
+    // #475: `{ code, stdout, stderr }` capture.
+    fn fields(v: &Value) -> (f64, String, String) {
+        let Value::Object(o) = v else {
+            panic!("execFileCapture must return an object, got {v:?}")
+        };
+        let b = o.borrow();
+        let num = |k: &str| match b.strings.get(k) {
+            Some(Value::Number(n)) => *n,
+            _ => f64::NAN,
+        };
+        let string = |k: &str| match b.strings.get(k) {
+            Some(Value::String(s)) => s.to_string(),
+            _ => String::new(),
+        };
+        (num("code"), string("stdout"), string("stderr"))
+    }
+
+    #[test]
+    fn execfile_capture_returns_code_stdout_stderr() {
+        // Success: stdout captured, code 0, stderr empty.
+        let args = Value::Array(VmRef::new(vec![Value::String("captured".into())]));
+        let (code, out, err) =
+            fields(&process_exec_file_capture(&[Value::String("echo".into()), args]));
+        assert_eq!(code, 0.0);
+        assert_eq!(out.trim(), "captured");
+        assert_eq!(err, "");
+        // Non-zero exit is reported, not an error.
+        let (code, _, _) = fields(&process_exec_file_capture(&[Value::String("false".into())]));
+        assert_eq!(code, 1.0);
+        // Spawn failure → code -1 with the OS error in stderr (never panics).
+        let (code, out, err) =
+            fields(&process_exec_file_capture(&[Value::String("/no/such/prog/xyz".into())]));
+        assert_eq!(code, -1.0);
+        assert!(out.is_empty());
+        assert!(!err.is_empty());
+        // Empty program → 0 / empty (mirrors execFile).
+        let (code, out, err) = fields(&process_exec_file_capture(&[]));
+        assert_eq!(code, 0.0);
+        assert!(out.is_empty() && err.is_empty());
+    }
 }
 
 #[cfg(feature = "fs")]
@@ -1308,6 +1468,11 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
         Value::Array(arr) => {
             let idx = match index {
                 Value::Number(n) => *n as usize,
+                // Canonical integer string key ("0","1",…) indexes the array (#432); other keys → Null.
+                Value::String(s) => match tishlang_core::str_to_array_index(s) {
+                    Some(i) => i,
+                    None => return Value::Null,
+                },
                 _ => return Value::Null,
             };
             arr.borrow().get(idx).cloned().unwrap_or(Value::Null)
@@ -1316,6 +1481,10 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
         Value::NumberArray(arr) => {
             let idx = match index {
                 Value::Number(n) => *n as usize,
+                Value::String(s) => match tishlang_core::str_to_array_index(s) {
+                    Some(i) => i,
+                    None => return Value::Null,
+                },
                 _ => return Value::Null,
             };
             arr.borrow().get(idx).copied().map(Value::Number).unwrap_or(Value::Null)
@@ -1416,6 +1585,11 @@ pub fn set_index(obj: &Value, idx: &Value, val: Value) -> Value {
         Value::Array(arr) => {
             let index = match idx {
                 Value::Number(n) => *n as usize,
+                // Canonical integer string key → index (#432); a non-index string key is a no-op write.
+                Value::String(s) => match tishlang_core::str_to_array_index(s) {
+                    Some(i) => i,
+                    None => return val,
+                },
                 _ => panic!("Array index must be number"),
             };
             let mut arr_mut = arr.borrow_mut();
@@ -1432,6 +1606,11 @@ pub fn set_index(obj: &Value, idx: &Value, val: Value) -> Value {
         Value::NumberArray(arr) => {
             let index = match idx {
                 Value::Number(n) => *n as usize,
+                // Canonical integer string key → index (#432); a non-index string key is a no-op write.
+                Value::String(s) => match tishlang_core::str_to_array_index(s) {
+                    Some(i) => i,
+                    None => return val,
+                },
                 _ => panic!("Array index must be number"),
             };
             let mut arr_mut = arr.borrow_mut();
@@ -1530,6 +1709,11 @@ mod timers;
 #[cfg(any(feature = "http", feature = "promise"))]
 mod promise;
 
+/// Node-compatible fs surface (sync + `fs/promises`). Referenced by the backends via
+/// `tishlang_runtime::fs_ext::*`. See issue #122.
+#[cfg(feature = "fs")]
+pub mod fs_ext;
+
 #[cfg(feature = "http")]
 mod native_promise;
 
@@ -1830,6 +2014,48 @@ pub fn string_match_regex(s: &Value, regexp: &Value) -> Value {
     }
 }
 
+/// `String.prototype.matchAll(regexp)` — an ITERATOR over every match, each an exec-style match object
+/// (`{ "0", ...groups, index, input, groups }`). Per ECMA the regexp must be global, else a `TypeError`
+/// is parked; a non-RegExp argument is coerced to a global regex. Reuses `regexp_exec_impl` so the
+/// match objects are byte-identical to `exec`/`match`, then wraps them in the shared iterator.
+#[cfg(feature = "regex")]
+pub fn string_match_all_regex(s: &Value, regexp: &Value) -> Value {
+    let input = match s {
+        Value::String(s) => s.as_ref(),
+        _ => return Value::Null,
+    };
+    let re_cell = match regexp {
+        Value::RegExp(re) => re.clone(),
+        other => {
+            let pattern = other.to_display_string();
+            match tishlang_core::TishRegExp::new(&pattern, "g") {
+                Ok(re) => tishlang_core::VmRef::new(re),
+                Err(_) => return Value::Null,
+            }
+        }
+    };
+    if !re_cell.borrow().flags.global {
+        tishlang_core::set_pending_throw(tishlang_core::type_error(
+            "String.prototype.matchAll called with a non-global RegExp argument",
+        ));
+        return Value::Null;
+    }
+    let mut results: Vec<Value> = Vec::new();
+    {
+        let mut re = re_cell.borrow_mut();
+        re.last_index = 0;
+        loop {
+            let m = regexp_exec_impl(&mut re, input);
+            if matches!(m, Value::Null) {
+                break;
+            }
+            results.push(m);
+        }
+        re.last_index = 0;
+    }
+    tishlang_builtins::iterator::array_iterator(results)
+}
+
 #[cfg(feature = "regex")]
 fn string_replace_regex_or_callback(s: &Value, search: &Value, replacement: &Value) -> Value {
     let input = match s {

package/crates/tish_ui/src/jsx.rs

@@ -188,7 +188,12 @@ fn collect_fun_decl_names_stmt(stmt: &Statement, names: &mut HashSet<String>) {
             }
             collect_fun_decl_names_stmt(body, names);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             collect_fun_decl_names_expr(iterable, names);
             collect_fun_decl_names_stmt(body, names);
         }
@@ -646,7 +651,12 @@ fn stmt_contains_jsx_fragment(stmt: &tishlang_ast::Statement) -> bool {
                 || update.as_ref().is_some_and(expr_contains_jsx_fragment)
                 || stmt_contains_jsx_fragment(body)
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             expr_contains_jsx_fragment(iterable) || stmt_contains_jsx_fragment(body)
         }
         Statement::Switch {
@@ -827,7 +837,12 @@ fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
                 || update.as_ref().is_some_and(expr_contains_jsx)
                 || stmt_contains_jsx(body)
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             expr_contains_jsx(iterable) || stmt_contains_jsx(body)
         }
         Statement::Switch {

package/crates/tish_vm/src/jit.rs

@@ -3634,7 +3634,7 @@ mod tests {
     #[test]
     fn osr_region_handles_branches() {
         let chunk = top_chunk(
-            "let s = 0.0\nlet i = 0.0\nwhile (i < 20.0) { if (i % 2.0 == 0.0) { s = s + i }; i = i + 1.0 }\n",
+            "let s = 0.0\nlet i = 0.0\nwhile (i < 20.0) { if (i % 2.0 === 0.0) { s = s + i }; i = i + 1.0 }\n",
         );
         let (header, end) = first_region(&chunk);
         let lf =