@tishlang/tish-lsp 2.16.13 → 2.35.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 {
@@ -1308,6 +1361,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 +1374,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 +1478,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 +1499,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 +1602,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 +1907,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 =