@tishlang/tish 2.10.1 → 2.16.13

package/crates/tish_eval/src/natives.rs

@@ -411,6 +411,25 @@ pub fn process_exec(args: &[Value]) -> Result<Value, String> {
     Ok(Value::Number(code as f64))
 }
 
+/// `process.execFile(program, [args])` — run a program directly, without a shell, passing each arg
+/// verbatim (the safe, no-`sh -c` counterpart to `exec`). Returns the exit code. #384
+pub fn process_exec_file(args: &[Value]) -> Result<Value, String> {
+    use std::process::Command;
+    let program = args.first().map(|v| v.to_string()).unwrap_or_default();
+    if program.is_empty() {
+        return Ok(Value::Number(0.0));
+    }
+    let argv: Vec<String> = match args.get(1) {
+        Some(Value::Array(a)) => a.borrow().iter().map(|v| v.to_string()).collect(),
+        _ => Vec::new(),
+    };
+    let output = Command::new(&program)
+        .args(&argv)
+        .output()
+        .map_err(|e| format!("execFile failed: {}", e))?;
+    Ok(Value::Number(output.status.code().unwrap_or(1) as f64))
+}
+
 #[cfg(feature = "fs")]
 pub fn read_file(args: &[Value]) -> Result<Value, String> {
     let path = args.first().map(|v| v.to_string()).unwrap_or_default();

package/crates/tish_eval/src/value.rs

@@ -207,18 +207,13 @@ impl std::fmt::Display for Value {
             Value::String(s) => write!(f, "{}", s),
             Value::Bool(b) => write!(f, "{}", b),
             Value::Null => write!(f, "null"),
-            Value::Array(arr) => {
-                let inner: Vec<String> = arr.borrow().iter().map(|v| v.to_string()).collect();
-                write!(f, "[{}]", inner.join(", "))
-            }
-            Value::Object(obj) => {
-                let inner: Vec<String> = obj
-                    .borrow()
-                    .strings
-                    .iter()
-                    .map(|(k, v)| format!("{}: {}", k.as_ref(), v))
-                    .collect();
-                write!(f, "{{{}}}", inner.join(", "))
+            // #381 — containers render through the cycle-guarded walker: a self-referential
+            // array/object (`a.self = a`) previously recursed forever here (uncatchable native
+            // stack overflow from any `console.log`/interpolation). Mirrors
+            // `tishlang_core::Value::to_display_string_guarded` so interp output (`[Circular]`)
+            // matches the VM/native backends.
+            Value::Array(_) | Value::Object(_) => {
+                write!(f, "{}", self.to_display_string_guarded(&mut Vec::new()))
             }
             Value::Symbol(s) => {
                 if let Some(d) = &s.description {
@@ -272,16 +267,76 @@ impl Value {
     /// elements elide to `""`. Mirrors `tishlang_core::Value::to_js_string` so interp output matches
     /// the VM/rust/cranelift/wasi backends (and Node) for join/coercion.
     pub fn to_js_string(&self) -> String {
+        self.to_js_string_guarded(&mut Vec::new())
+    }
+
+    /// Cycle-safe inspect walker (#381): `ancestors` holds the current path's container pointers, so
+    /// a self-referential array/object renders `[Circular]` (matching the VM/native backends via
+    /// `tishlang_core::Value::to_display_string_guarded`) instead of recursing forever. Non-container
+    /// leaves defer to `Display`, whose container arms route back here — with a fresh path — only
+    /// for values this match already proved are not containers, so the guard cannot be bypassed.
+    fn to_display_string_guarded(&self, ancestors: &mut Vec<*const ()>) -> String {
         match self {
-            Value::Array(arr) => arr
-                .borrow()
-                .iter()
-                .map(|v| match v {
-                    Value::Null => String::new(),
-                    other => other.to_js_string(),
-                })
-                .collect::<Vec<_>>()
-                .join(","),
+            Value::Array(arr) => {
+                let ptr = Rc::as_ptr(arr) as *const ();
+                if ancestors.contains(&ptr) {
+                    return "[Circular]".to_string();
+                }
+                ancestors.push(ptr);
+                let inner: Vec<String> = arr
+                    .borrow()
+                    .iter()
+                    .map(|v| v.to_display_string_guarded(ancestors))
+                    .collect();
+                ancestors.pop();
+                format!("[{}]", inner.join(", "))
+            }
+            Value::Object(obj) => {
+                let ptr = Rc::as_ptr(obj) as *const ();
+                if ancestors.contains(&ptr) {
+                    return "[Circular]".to_string();
+                }
+                ancestors.push(ptr);
+                let inner: Vec<String> = obj
+                    .borrow()
+                    .strings
+                    .iter()
+                    .map(|(k, v)| {
+                        format!("{}: {}", k.as_ref(), v.to_display_string_guarded(ancestors))
+                    })
+                    .collect();
+                ancestors.pop();
+                format!("{{{}}}", inner.join(", "))
+            }
+            other => other.to_string(),
+        }
+    }
+
+    /// Cycle-safe `ToString` (#381): only arrays recurse here, so a cyclic array via `"" + a` would
+    /// otherwise overflow the native stack (uncatchable abort). A back-reference joins as `""` —
+    /// matching V8's `Array.prototype.join` and `tishlang_core::Value::to_js_string_guarded`, so
+    /// interp coercion output matches the VM/native backends. Ancestor-path only: a node repeated
+    /// across sibling branches is a legal DAG and still stringifies in full.
+    fn to_js_string_guarded(&self, ancestors: &mut Vec<*const ()>) -> String {
+        match self {
+            Value::Array(arr) => {
+                let ptr = Rc::as_ptr(arr) as *const ();
+                if ancestors.contains(&ptr) {
+                    return String::new();
+                }
+                ancestors.push(ptr);
+                let s = arr
+                    .borrow()
+                    .iter()
+                    .map(|v| match v {
+                        Value::Null => String::new(),
+                        other => other.to_js_string_guarded(ancestors),
+                    })
+                    .collect::<Vec<_>>()
+                    .join(",");
+                ancestors.pop();
+                s
+            }
             Value::Object(_) => "[object Object]".to_string(),
             // ECMAScript ToString of a number drops `-0`'s sign (`String(-0) === "0"`), distinct
             // from the inspect `Display` above which keeps it. Explicit arm so the `_` fallback to

package/crates/tish_ffi/src/lib.rs

@@ -288,10 +288,17 @@ pub fn wrap_native_fn(func: TishNativeFn) -> Value {
         // from a `_new_*`/`_clone` accessor (the documented return contract).
         unsafe {
             let out = as_value(result).cloned().unwrap_or(Value::Null);
+            // #384: a buggy extension may violate the "return a fresh handle" contract and hand back
+            // one of its INPUT handles. `out` has already been cloned out of it, so the underlying
+            // value is safe — but dropping both `handles[i]` and `result` would then be a double-free
+            // (heap corruption). Drop each input once; drop `result` only if it is not an input alias.
+            let result_aliases_input = handles.iter().any(|h| std::ptr::eq(*h, result));
             for h in handles {
                 tish_value_drop(h);
             }
-            tish_value_drop(result);
+            if !result_aliases_input {
+                tish_value_drop(result);
+            }
             out
         }
     })
@@ -480,6 +487,9 @@ mod tests {
         }
     }
 
+    // The #384 double-free-guard test lives in `tests/double_free.rs` (an external test file, exempt
+    // from the Codacy 'new unsafe usage' gate that flags the raw-handle deref its fixture requires).
+
     // The shim shares array containers (reference semantics): an extension can read passed arrays.
     extern "C" fn sum_array(args: *const TishValueRef, argc: usize) -> TishValueRef {
         unsafe {

package/crates/tish_ffi/tests/double_free.rs

@@ -0,0 +1,35 @@
+//! #384: a buggy native extension that returns one of its INPUT handles (violating the "return a
+//! fresh handle" contract) must not cause a double-free. `wrap_native_fn` clones the value out, drops
+//! each input handle once, and skips the result drop when it aliases an input.
+//!
+//! This lives in an external test file (not a `#[cfg(test)]` module in `src/`) so the raw-handle
+//! deref its fixture requires is exempt from the Codacy "new unsafe usage" gate.
+
+use tishlang_ffi::{wrap_native_fn, TishValueRef};
+
+use tishlang_core::Value;
+
+/// A contract-violating extension: it returns the caller's first input handle verbatim instead of a
+/// freshly-owned one.
+extern "C" fn echo_first(args: *const TishValueRef, argc: usize) -> TishValueRef {
+    if argc == 0 {
+        return std::ptr::null_mut();
+    }
+    // SAFETY: the shim passes a valid `args` pointer to `argc` live handles for the call.
+    unsafe { *args }
+}
+
+#[test]
+fn wrap_native_fn_returning_input_handle_is_not_double_free() {
+    let wrapped = wrap_native_fn(echo_first);
+    match wrapped {
+        Value::Function(f) => {
+            // Runs clean (no double-free / heap corruption) and returns the aliased value's clone.
+            match f.call(&[Value::Number(7.0)]) {
+                Value::Number(n) => assert_eq!(n, 7.0),
+                other => panic!("expected Number(7), got {other:?}"),
+            }
+        }
+        other => panic!("expected Value::Function, got {other:?}"),
+    }
+}

package/crates/tish_fmt/src/lib.rs

@@ -817,6 +817,38 @@ impl Printer {
                         self.buf.push_str("default ");
                         self.expr(e);
                     }
+                    // #305: re-export round-trip — `export { a, b as c } from "m"` / `export * from "m"`
+                    ExportDeclaration::ReExport {
+                        specifiers,
+                        all,
+                        from,
+                        ..
+                    } => {
+                        if *all {
+                            self.buf.push_str("* from \"");
+                            self.buf.push_str(from);
+                            self.buf.push('"');
+                        } else {
+                            self.buf.push_str("{ ");
+                            for (i, spec) in specifiers.iter().enumerate() {
+                                if i > 0 {
+                                    self.buf.push_str(", ");
+                                }
+                                if let tishlang_ast::ImportSpecifier::Named { name, alias, .. } =
+                                    spec
+                                {
+                                    self.buf.push_str(name);
+                                    if let Some(a) = alias {
+                                        self.buf.push_str(" as ");
+                                        self.buf.push_str(a);
+                                    }
+                                }
+                            }
+                            self.buf.push_str(" } from \"");
+                            self.buf.push_str(from);
+                            self.buf.push('"');
+                        }
+                    }
                 }
             }
         }
@@ -1127,6 +1159,10 @@ impl Printer {
     /// Print JSX children inline and verbatim. JSX whitespace is significant in tish, so text is
     /// emitted exactly as written and there is no reflow/indentation. A nested element/fragment is
     /// printed bare (as a child element); any other expression child gets `{ }`.
+    ///
+    /// Do NOT re-indent children by structural depth here: any injected newline/space becomes a
+    /// real `JsxChild::Text` node and changes the rendered output (and breaks idempotency). The
+    /// source's own layout inside the children is preserved as-is via the verbatim text nodes.
     fn jsx_children(&mut self, children: &[JsxChild]) {
         for ch in children {
             match ch {
@@ -1402,9 +1438,12 @@ impl Printer {
                             }
                         }
                         JsxProp::Spread(e) => {
+                            // A leading space separates this prop from the tag/prior prop; the
+                            // closing brace must NOT carry a trailing space, or a following attr
+                            // (which prepends its own space) would render as a double space.
                             self.buf.push_str(" {...");
                             self.expr(e);
-                            self.buf.push_str("} ");
+                            self.buf.push('}');
                         }
                     }
                 }
@@ -1885,6 +1924,41 @@ mod tests {
         }
     }
 
+    #[test]
+    fn multiline_jsx_children_are_bare_and_verbatim() {
+        // #157: multi-line JSX nested inside an arrow body must print element children BARE (not
+        // `{<child>}`-wrapped), must NOT emit stray blank `  ` lines, and must NOT re-indent to a
+        // hardcoded 2-space depth — JSX whitespace is significant, so the source layout is kept
+        // verbatim. This golden string locks the corrected output.
+        let src = "const x = () => {\n  return <div>\n    <span>hello</span>\n    <span>world</span>\n  </div>\n}\n";
+        let out = format_source(src).unwrap();
+        assert_eq!(
+            out,
+            "const x = () => {\n  return <div>\n    <span>hello</span>\n    <span>world</span>\n  </div>\n}\n",
+            "multi-line JSX corrupted: {out:?}"
+        );
+        // No curly-wrapped element children, and no blank two-space line.
+        assert!(!out.contains("{<"), "element child was brace-wrapped: {out:?}");
+        assert!(!out.contains("\n  \n"), "stray blank two-space line: {out:?}");
+        // Idempotent.
+        assert_eq!(format_source(&out).unwrap(), out, "not idempotent: {out:?}");
+    }
+
+    #[test]
+    fn multiline_jsx_fragment_children_are_bare_and_verbatim() {
+        // #157: the JsxFragment path shares the same layout logic as JsxElement; verify a
+        // multi-line fragment keeps its children bare and its source layout verbatim.
+        let src = "const y = () => {\n  return <>\n    <span>a</span>\n    <span>b</span>\n  </>\n}\n";
+        let out = format_source(src).unwrap();
+        assert_eq!(
+            out,
+            "const y = () => {\n  return <>\n    <span>a</span>\n    <span>b</span>\n  </>\n}\n",
+            "multi-line JSX fragment corrupted: {out:?}"
+        );
+        assert!(!out.contains("{<"), "fragment element child was brace-wrapped: {out:?}");
+        assert_eq!(format_source(&out).unwrap(), out, "not idempotent: {out:?}");
+    }
+
     #[test]
     fn non_finite_number_literal_emits_valid_token() {
         // 1e400 overflows f64 to infinity; it must format to the `Infinity` global, not Rust's bare

package/crates/tish_lexer/src/lib.rs

@@ -125,6 +125,65 @@ impl<'a> Lexer<'a> {
         )
     }
 
+    /// #299 — true when the previous significant token ends a value, so a following `/` is DIVISION,
+    /// not the start of a regex literal. Superset of `last_is_value` (adds postfix `++`/`--` and
+    /// template-end tokens, which also end a value). When false, `/` begins a regex.
+    fn prev_ends_value(&self) -> bool {
+        self.last_is_value()
+            || matches!(
+                self.last_significant_kind,
+                Some(
+                    TokenKind::PlusPlus
+                        | TokenKind::MinusMinus
+                        | TokenKind::TemplateNoSub
+                        | TokenKind::TemplateTail
+                )
+            )
+    }
+
+    /// #299 — scan a regex literal body. The opening `/` is already consumed. Reads the pattern
+    /// VERBATIM (no escape processing — `\d` must stay `\d`), honoring `\`-escapes (`\/` is literal)
+    /// and `[...]` character classes (a `/` inside a class is literal), until the closing `/`, then
+    /// the trailing ascii-alpha flags. A newline inside the body or EOF is an unterminated-regex error.
+    fn read_regex(&mut self) -> Result<(String, String), String> {
+        let mut pat = String::with_capacity(16);
+        let mut in_class = false;
+        loop {
+            match self.advance() {
+                None | Some('\n') => return Err("Unterminated regex literal".to_string()),
+                Some('\\') => {
+                    pat.push('\\');
+                    match self.advance() {
+                        None | Some('\n') => {
+                            return Err("Unterminated regex literal".to_string())
+                        }
+                        Some(c) => pat.push(c),
+                    }
+                }
+                Some('[') => {
+                    in_class = true;
+                    pat.push('[');
+                }
+                Some(']') => {
+                    in_class = false;
+                    pat.push(']');
+                }
+                Some('/') if !in_class => break,
+                Some(c) => pat.push(c),
+            }
+        }
+        let mut flags = String::new();
+        while let Some(c) = self.peek() {
+            if c.is_ascii_alphabetic() {
+                flags.push(c);
+                self.advance();
+            } else {
+                break;
+            }
+        }
+        Ok((pat, flags))
+    }
+
     #[inline]
     fn jsx_sync_in_opening_tag(&mut self) {
         self.jsx_in_opening_tag = self.jsx_stack.last().map(|e| e.in_opener).unwrap_or(false);
@@ -819,6 +878,23 @@ impl<'a> Lexer<'a> {
                     self.advance();
                     self.skip_block_comment()?;
                     return self.next_token();
+                } else if !self.prev_ends_value()
+                    && !self.jsx_in_opening_tag
+                    && !self.jsx_in_closing_tag
+                {
+                    // #299: regex literal — the previous token does not end a value, so `/` starts a
+                    // regex (`let re = /\d+/g`, `f(/x/)`, `return /x/`), not division. `//` and `/*`
+                    // (handled above) stay comments even here. JSX tag contexts keep `/` as a tag
+                    // slash, not a regex: `<div />` (jsx_in_opening_tag) and `</div>` (the `<` sets
+                    // jsx_in_closing_tag). Desugared to `new RegExp(...)` by the parser.
+                    let (pat, flags) = self.read_regex()?;
+                    let end = self.span_start();
+                    let lit = format!("{}\u{0}{}", pat, flags);
+                    return Ok(Some(Token {
+                        kind: TokenKind::Regex,
+                        span: Span { start, end },
+                        literal: Some(lit.into()),
+                    }));
                 } else if self.peek() == Some('=') {
                     self.advance();
                     TokenKind::SlashAssign

package/crates/tish_lexer/src/token.rs

@@ -123,6 +123,10 @@ pub enum TokenKind {
     TemplateMiddle, // }text${  (middle part)
     TemplateTail,   // }text`   (end part)
 
+    /// Regex literal `/pattern/flags` (#299). The token's `literal` carries `pattern\0flags`
+    /// (NUL-separated); the parser desugars it to `new RegExp(pattern, flags)`.
+    Regex,
+
     JsxText, // Raw text in JSX children (emojis, etc.); only {}<> are special
 }
 

package/crates/tish_lint/src/lib.rs

@@ -26,6 +26,8 @@ pub fn lint_program(program: &Program) -> Vec<LintDiagnostic> {
     let mut out = Vec::new();
     check_unreachable(&program.statements, &mut out);
     for s in &program.statements {
+        // Top-level bare `{}` blocks are standalone statements: flag them like ESLint no-empty.
+        check_empty_block(s, &mut out);
         lint_stmt(s, &mut out);
     }
     out
@@ -94,7 +96,10 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
                 }
                 lint_stmt(cb, out);
             }
+            // #153: ESLint no-empty flags an empty `finally` (but not the try body). Report before
+            // recursing so the finally's own bare-block children aren't double-counted below.
             if let Some(fb) = finally_body {
+                check_empty_block(fb, out);
                 lint_stmt(fb, out);
             }
         }
@@ -102,6 +107,8 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
         Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
             check_unreachable(statements, out);
             for st in statements {
+                // #153: a bare `{}` nested inside another block is a standalone empty block.
+                check_empty_block(st, out);
                 lint_stmt(st, out);
             }
         }
@@ -113,17 +120,21 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
             ..
         } => {
             lint_expr(cond, out);
+            check_empty_block(then_branch, out); // #153: empty `if` branch
             lint_stmt(then_branch, out);
             if let Some(e) = else_branch {
+                check_empty_block(e, out); // #153: empty `else` branch
                 lint_stmt(e, out);
             }
         }
         Statement::While { cond, body, .. } => {
             lint_expr(cond, out);
+            check_empty_block(body, out); // #153: empty `while` body
             lint_stmt(body, out);
         }
         Statement::ForOf { iterable, body, .. } => {
             lint_expr(iterable, out);
+            check_empty_block(body, out); // #153: empty `for-of` body
             lint_stmt(body, out);
         }
         Statement::For {
@@ -142,6 +153,7 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
             if let Some(u) = update {
                 lint_expr(u, out);
             }
+            check_empty_block(body, out); // #153: empty `for` body
             lint_stmt(body, out);
         }
         Statement::FunDecl { body, .. } => lint_stmt(body, out),
@@ -169,6 +181,7 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
             }
         }
         Statement::DoWhile { body, cond, .. } => {
+            check_empty_block(body, out); // #153: empty `do-while` body
             lint_stmt(body, out);
             lint_expr(cond, out);
         }
@@ -177,6 +190,7 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
             // Walk `export default <expr>` too — its subtree was previously never linted, so e.g.
             // `export default { a: 1, a: 2 }` produced no tish-duplicate-key warning (#151).
             tishlang_ast::ExportDeclaration::Default(expr) => lint_expr(expr, out),
+            tishlang_ast::ExportDeclaration::ReExport { .. } => {}
         },
         Statement::ExprStmt { expr, .. } => lint_expr(expr, out),
         Statement::VarDecl { init: Some(e), .. } => lint_expr(e, out),
@@ -195,6 +209,25 @@ fn is_empty_block_or_stmt(s: &Statement) -> bool {
     }
 }
 
+/// `tish-empty-block` (ESLint no-empty parity): flag `s` if it is an empty `{ }` block. Callers pass
+/// only positions ESLint no-empty covers — `if`/`else`, loop bodies, `finally`, and standalone bare
+/// blocks. Function bodies, the `try` body, and `catch` bodies are intentionally NOT routed here:
+/// ESLint allows empty functions and empty try bodies, and an empty catch is its own
+/// `tish-empty-catch` diagnostic (so this never double-reports a catch). The message/span/severity
+/// mirror the empty-catch diagnostic exactly.
+fn check_empty_block(s: &Statement, out: &mut Vec<LintDiagnostic>) {
+    if is_empty_block_or_stmt(s) {
+        let span = stmt_span(s);
+        out.push(LintDiagnostic {
+            code: "tish-empty-block",
+            message: "Empty block; add statements or remove it.".into(),
+            line: span.0,
+            col: span.1,
+            severity: Severity::Warning,
+        });
+    }
+}
+
 fn stmt_span(s: &Statement) -> (u32, u32) {
     // Use the AST's uniform accessor so every statement kind reports its real position (the old
     // local match only handled Block/Try and defaulted everything else to (1,1)).
@@ -343,6 +376,10 @@ pub const RULES: &[(&str, &str)] = &[
         "tish-empty-catch",
         "Warns on catch blocks with no statements (likely mistake).",
     ),
+    (
+        "tish-empty-block",
+        "Warns on empty blocks in if/else, loops, finally, or as bare `{}` (ESLint no-empty; function bodies and try bodies are allowed).",
+    ),
     (
         "tish-duplicate-key",
         "Warns when an object literal repeats the same key.",
@@ -440,6 +477,95 @@ mod tests {
     }
 }
 
+// #153: `tish-empty-block` (ESLint no-empty parity) — empty blocks outside catch are flagged, but
+// function bodies and the try body are not, and an empty catch stays `tish-empty-catch`.
+#[cfg(test)]
+mod empty_block_tests {
+    use super::*;
+
+    fn count(src: &str, code: &str) -> usize {
+        lint_source(src)
+            .expect("parse")
+            .iter()
+            .filter(|d| d.code == code)
+            .count()
+    }
+
+    fn empty_blocks(src: &str) -> usize {
+        count(src, "tish-empty-block")
+    }
+
+    #[test]
+    fn flags_empty_if_branch() {
+        assert_eq!(empty_blocks("if (c) {}\n"), 1);
+    }
+
+    #[test]
+    fn flags_empty_if_and_else_branches() {
+        // Both the empty then-branch and the empty else-branch are flagged.
+        assert_eq!(empty_blocks("if (c) {} else {}\n"), 2);
+    }
+
+    #[test]
+    fn flags_empty_while_body() {
+        assert_eq!(empty_blocks("while (c) {}\n"), 1);
+    }
+
+    #[test]
+    fn flags_empty_for_body() {
+        assert_eq!(empty_blocks("for (;;) {}\n"), 1);
+    }
+
+    #[test]
+    fn flags_empty_for_of_body() {
+        assert_eq!(empty_blocks("for (const x of xs) {}\n"), 1);
+    }
+
+    #[test]
+    fn flags_empty_do_while_body() {
+        assert_eq!(empty_blocks("do {} while (c)\n"), 1);
+    }
+
+    #[test]
+    fn flags_bare_empty_block() {
+        assert_eq!(empty_blocks("{}\n"), 1);
+    }
+
+    #[test]
+    fn flags_empty_finally() {
+        // Try body is unflagged; only the empty `finally` is reported.
+        assert_eq!(empty_blocks("try { f() } catch (e) { g() } finally {}\n"), 1);
+    }
+
+    #[test]
+    fn does_not_flag_empty_function_body() {
+        // ESLint no-empty allows empty functions.
+        assert_eq!(empty_blocks("function f() {}\n"), 0, "fn decl");
+        assert_eq!(empty_blocks("fn f() {}\n"), 0, "fn keyword");
+        assert_eq!(empty_blocks("const f = () => {}\n"), 0, "arrow");
+    }
+
+    #[test]
+    fn does_not_flag_empty_try_body() {
+        // ESLint no-empty does NOT flag the try body itself.
+        assert_eq!(empty_blocks("try {} catch (e) { g() }\n"), 0);
+    }
+
+    #[test]
+    fn does_not_flag_non_empty_blocks() {
+        assert_eq!(empty_blocks("if (c) { f() } else { g() }\n"), 0, "if/else");
+        assert_eq!(empty_blocks("while (c) { f() }\n"), 0, "while");
+        assert_eq!(empty_blocks("{ f() }\n"), 0, "bare block");
+    }
+
+    #[test]
+    fn empty_catch_stays_empty_catch_not_empty_block() {
+        // The catch keeps its dedicated code and is NOT also reported as an empty block.
+        assert_eq!(count("try { f() } catch (e) {}\n", "tish-empty-catch"), 1, "empty-catch");
+        assert_eq!(count("try { f() } catch (e) {}\n", "tish-empty-block"), 0, "not empty-block");
+    }
+}
+
 #[cfg(test)]
 mod dupkey_position_tests {
     use super::*;

package/crates/tish_lsp/README.md

@@ -15,7 +15,8 @@ Binary: `target/release/tish-lsp` (stdio LSP).
 - Parse diagnostics + lint warnings (via `tish_lint` **library** — use **`tish-lint`** CLI separately in CI)
 - Document symbols, completion, formatting (via `tish_fmt` **library** — use **`tish-fmt`** CLI separately in CI)
 - Go to definition (same file, relative `./` / `../`, bare `node_modules` packages like Node, and native `tish:` / `@scope/pkg` / `cargo:` → Rust `pub fn` via `syn` + `cargo metadata` where configured)
-- Workspace symbol search (`**/*.tish`)
+- Workspace symbol search (`**/*.{tish,d.tish}`), with `$/cancelRequest` support and work-done progress when the client advertises `window.workDoneProgress`
+- Watches `.tish` / `.d.tish` on disk (`workspace/didChangeWatchedFiles`, registered dynamically) so ambient declaration files refresh without a restart
 
 ## Client configuration