@tishlang/tish-format 2.2.7 → 2.9.0

package/crates/tish_eval/src/regex.rs

@@ -254,46 +254,54 @@ pub fn string_split(input: &str, separator: &Value, limit: Option<usize>) -> Val
         return Value::Array(Rc::new(RefCell::new(Vec::new())));
     }
 
-    match separator {
+    // JS semantics in every branch: split the string fully, then truncate the result to `limit`.
+    // (Rust's `splitn` keeps the unsplit remainder in the last slot — that's Python-style maxsplit,
+    // not JS — so we must split fully and `truncate`. `truncate(usize::MAX)` is a no-op for the
+    // no-limit case.) This mirrors `tish_builtins::string::split_limit` /
+    // `tishlang_runtime::string_split_regex` so interp, vm, and the native backends agree.
+    let mut result: Vec<Value> = match separator {
         Value::RegExp(re) => {
             let re = re.borrow();
-            let mut result = Vec::new();
+            let mut parts = Vec::new();
             let mut last_end = 0;
-
             for mat in re.regex.find_iter(input) {
                 match mat {
                     Ok(m) => {
-                        if result.len() >= max - 1 {
-                            break;
-                        }
-                        result.push(Value::String(input[last_end..m.start()].into()));
+                        parts.push(Value::String(input[last_end..m.start()].into()));
                         last_end = m.end();
                     }
                     Err(_) => break,
                 }
             }
-
-            if result.len() < max {
-                result.push(Value::String(input[last_end..].into()));
-            }
-
-            Value::Array(Rc::new(RefCell::new(result)))
-        }
-        Value::String(sep) => {
-            let parts: Vec<Value> = input
-                .splitn(max, sep.as_ref())
-                .map(|s| Value::String(s.into()))
-                .collect();
-            Value::Array(Rc::new(RefCell::new(parts)))
+            parts.push(Value::String(input[last_end..].into()));
+            parts
         }
-        Value::Null => Value::Array(Rc::new(RefCell::new(vec![Value::String(input.into())]))),
+        // JS `split("")` → the string's chars with no surrounding empties (`"".split("")` → `[]`),
+        // unlike Rust's `str::split("")`. Mirrors `tish_builtins::string::split_limit`. #247
+        Value::String(sep) if sep.is_empty() => input
+            .chars()
+            .map(|c| Value::String(c.to_string().into()))
+            .collect(),
+        Value::String(sep) => input
+            .split(sep.as_ref())
+            .map(|s| Value::String(s.into()))
+            .collect(),
+        Value::Null => vec![Value::String(input.into())],
         _ => {
             let sep_str = separator.to_string();
-            let parts: Vec<Value> = input
-                .splitn(max, &sep_str)
-                .map(|s| Value::String(s.into()))
-                .collect();
-            Value::Array(Rc::new(RefCell::new(parts)))
+            if sep_str.is_empty() {
+                input
+                    .chars()
+                    .map(|c| Value::String(c.to_string().into()))
+                    .collect()
+            } else {
+                input
+                    .split(&sep_str)
+                    .map(|s| Value::String(s.into()))
+                    .collect()
+            }
         }
-    }
+    };
+    result.truncate(max);
+    Value::Array(Rc::new(RefCell::new(result)))
 }

package/crates/tish_eval/src/value.rs

@@ -197,6 +197,10 @@ impl std::fmt::Debug for Value {
 impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            // Inspect form (`console.log`): keeps the sign of negative zero, unlike the ECMAScript
+            // ToString used by `to_js_string`. Matches Node's console output (`console.log(-0)` →
+            // `-0`). `to_js_string` has an explicit `Number` arm so ToString still drops it. (#247)
+            Value::Number(n) if *n == 0.0 && n.is_sign_negative() => write!(f, "-0"),
             // Match JS `Number.prototype.toString` (exponential past digit 21 / before −6),
             // shared with the VM/native path via `tishlang_core`.
             Value::Number(n) => write!(f, "{}", tishlang_core::js_number_to_string(*n)),
@@ -279,6 +283,10 @@ impl Value {
                 .collect::<Vec<_>>()
                 .join(","),
             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
+            // `to_string()` (inspect) is not used for numbers. (#247)
+            Value::Number(n) => tishlang_core::js_number_to_string(*n),
             _ => self.to_string(),
         }
     }

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "2.2.7"
+version = "2.9.0"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_fmt/src/lib.rs

@@ -248,7 +248,7 @@ impl Printer {
 
     fn object_prop(&mut self, pr: &ObjectProp) {
         match pr {
-            ObjectProp::KeyValue(k, v) => {
+            ObjectProp::KeyValue(k, v, _) => {
                 self.buf.push_str(k.as_ref());
                 self.buf.push_str(": ");
                 self.expr(v);
@@ -2235,4 +2235,48 @@ let x = add(1, 2)
         tishlang_parser::parse(&out).unwrap();
         assert_eq!(format_source(&out).unwrap(), out, "not idempotent:\n{out}");
     }
+
+    /// Broad idempotence guard (#163): the existing tests targeted specific constructs (JSX, new-
+    /// expr) that *had* regressed, leaving structural blind spots. This sweeps a diverse corpus and
+    /// asserts, for every snippet, that (a) the formatted output re-parses and (b) re-formatting is
+    /// a fixed point — so any future construct that formats non-idempotently is caught here.
+    #[test]
+    fn format_is_idempotent_over_a_corpus() {
+        let corpus = [
+            "let a = { x: 1, y: { z: [1, 2, 3] } }\n",
+            "let f = (a, b) => a + b\n",
+            "let g = (x) => { return x * 2 }\n",
+            "const e = <div class=\"x\">{a}<span>b</span></div>\n",
+            "let frag = <><a>1</a><b>2</b></>\n",
+            "let n = new Foo(1).bar().baz\n",
+            "let n2 = new (getCtor())(arg)\n",
+            "let t = `a${b}c${d}e`\n",
+            "let lit = \"has a literal $ and a ${notInterp}\"\n",
+            "if (x) { return 1 } else if (y) { return 2 } else { return 3 }\n",
+            "for (let i = 0; i < n; i = i + 1) { f(i) }\n",
+            "for (const k of items) { use(k) }\n",
+            "while (cond) { step() }\n",
+            "do { once() } while (again)\n",
+            "switch (x) { case 1: f(); break; default: g() }\n",
+            "let u: number | string = 1\n",
+            "type T = { a: number, b: string[] }\n",
+            "export fn h(x: T): T { return x }\n",
+            "let v = a ? b : c\n",
+            "let w = a ?? b\n",
+            "let arr = [{ k: 1 }, { k: 2 }, ...rest]\n",
+            "let obj = { ...base, x: 1, y: 2 }\n",
+            "let chain = a?.b?.c\n",
+            "let big = 1e400\n",
+            "try { risky() } catch (e) { handle(e) } finally { cleanup() }\n",
+            "async fn af() { return await thing() }\n",
+            "import { a, b as c } from \"./m\"\nexport default a\n",
+        ];
+        for src in corpus {
+            let once = format_source(src).expect("format");
+            tishlang_parser::parse(&once)
+                .unwrap_or_else(|e| panic!("formatted output must re-parse for {src:?}: {e}\n{once}"));
+            let twice = format_source(&once).expect("re-format");
+            assert_eq!(once, twice, "non-idempotent for {src:?}:\n{once:?}\n  ->\n{twice:?}");
+        }
+    }
 }

package/crates/tish_lint/src/bin/tish-lint.rs

@@ -20,6 +20,11 @@ struct Cli {
     #[arg(long = "format", value_enum, default_value_t = OutputFormat::Text)]
     output_format: OutputFormat,
 
+    /// Exit non-zero if any WARNING is found (not just errors), so CI can gate on lint findings.
+    /// Without it, lint warnings print but the process exits 0 (only parse errors fail). (#154)
+    #[arg(long = "deny-warnings")]
+    deny_warnings: bool,
+
     #[arg(required = true)]
     paths: Vec<String>,
 }
@@ -36,7 +41,7 @@ struct Issue {
 
 fn main() {
     let cli = Cli::parse();
-    if let Err(e) = run(&cli.paths, cli.output_format) {
+    if let Err(e) = run(&cli.paths, cli.output_format, cli.deny_warnings) {
         eprintln!("{}", e);
         std::process::exit(1);
     }
@@ -67,7 +72,7 @@ fn collect_files(paths: &[String]) -> Result<Vec<PathBuf>, String> {
     Ok(files)
 }
 
-fn run(paths: &[String], format: OutputFormat) -> Result<(), String> {
+fn run(paths: &[String], format: OutputFormat, deny_warnings: bool) -> Result<(), String> {
     let files = collect_files(paths)?;
     let mut issues: Vec<Issue> = Vec::new();
     for f in files {
@@ -103,6 +108,13 @@ fn run(paths: &[String], format: OutputFormat) -> Result<(), String> {
     }
 
     let error_count = issues.iter().filter(|i| i.level == "error").count();
+    let warning_count = issues.iter().filter(|i| i.level == "warning").count();
+    // Always fail on errors (parse errors); with --deny-warnings, lint warnings fail too.
+    let fail_count = if deny_warnings {
+        error_count + warning_count
+    } else {
+        error_count
+    };
 
     match format {
         OutputFormat::Text => {
@@ -117,18 +129,15 @@ fn run(paths: &[String], format: OutputFormat) -> Result<(), String> {
                     i.message
                 );
             }
-            if error_count > 0 {
-                return Err(format!("{} issue(s)", error_count));
-            }
         }
         OutputFormat::Sarif => {
             print_sarif(&issues)?;
-            if error_count > 0 {
-                return Err(format!("{} issue(s)", error_count));
-            }
         }
     }
 
+    if fail_count > 0 {
+        return Err(format!("{} issue(s)", fail_count));
+    }
     Ok(())
 }
 

package/crates/tish_lint/src/lib.rs

@@ -24,12 +24,47 @@ pub struct LintDiagnostic {
 /// Run all default rules on parsed program.
 pub fn lint_program(program: &Program) -> Vec<LintDiagnostic> {
     let mut out = Vec::new();
+    check_unreachable(&program.statements, &mut out);
     for s in &program.statements {
         lint_stmt(s, &mut out);
     }
     out
 }
 
+/// `tish-unreachable-code` (no-unreachable): in a statement sequence, the first statement after an
+/// unconditional `return`/`throw`/`break`/`continue` sibling can never run. Flags only that first
+/// statement (not the whole tail — less noise) and skips hoisted `fn` declarations, which are valid
+/// after a terminator. Only a DIRECT-sibling terminator triggers it, so a conditional
+/// `if (c) return` followed by more statements is correctly NOT flagged.
+fn check_unreachable(stmts: &[Statement], out: &mut Vec<LintDiagnostic>) {
+    let mut terminated = false;
+    for st in stmts {
+        if terminated {
+            if matches!(st, Statement::FunDecl { .. }) {
+                continue; // function declarations hoist — reachable regardless of position
+            }
+            let (line, col) = stmt_span(st);
+            out.push(LintDiagnostic {
+                code: "tish-unreachable-code",
+                message: "Unreachable code after return/throw/break/continue.".into(),
+                line,
+                col,
+                severity: Severity::Warning,
+            });
+            return;
+        }
+        if matches!(
+            st,
+            Statement::Return { .. }
+                | Statement::Throw { .. }
+                | Statement::Break { .. }
+                | Statement::Continue { .. }
+        ) {
+            terminated = true;
+        }
+    }
+}
+
 /// Lint source: parse then lint. Parse errors are not reported here.
 pub fn lint_source(source: &str) -> Result<Vec<LintDiagnostic>, String> {
     let program = tishlang_parser::parse(source)?;
@@ -63,51 +98,86 @@ fn lint_stmt(s: &Statement, out: &mut Vec<LintDiagnostic>) {
                 lint_stmt(fb, out);
             }
         }
-        Statement::Block { statements, .. } => {
+        // Block and the transparent comma-declarator group (#141: Multi was previously skipped).
+        Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+            check_unreachable(statements, out);
             for st in statements {
                 lint_stmt(st, out);
             }
         }
+        // #140: control-flow CONDITION expressions are linted too, not just bodies.
         Statement::If {
+            cond,
             then_branch,
             else_branch,
             ..
         } => {
+            lint_expr(cond, out);
             lint_stmt(then_branch, out);
             if let Some(e) = else_branch {
                 lint_stmt(e, out);
             }
         }
-        Statement::While { body, .. } | Statement::ForOf { body, .. } => lint_stmt(body, out),
-        Statement::For { init, body, .. } => {
+        Statement::While { cond, body, .. } => {
+            lint_expr(cond, out);
+            lint_stmt(body, out);
+        }
+        Statement::ForOf { iterable, body, .. } => {
+            lint_expr(iterable, out);
+            lint_stmt(body, out);
+        }
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            ..
+        } => {
             if let Some(i) = init {
                 lint_stmt(i, out);
             }
+            if let Some(c) = cond {
+                lint_expr(c, out);
+            }
+            if let Some(u) = update {
+                lint_expr(u, out);
+            }
             lint_stmt(body, out);
         }
         Statement::FunDecl { body, .. } => lint_stmt(body, out),
         Statement::Switch {
+            expr,
             cases,
             default_body,
             ..
         } => {
-            for (_, stmts) in cases {
+            lint_expr(expr, out);
+            for (case_expr, stmts) in cases {
+                if let Some(ce) = case_expr {
+                    lint_expr(ce, out);
+                }
+                check_unreachable(stmts, out);
                 for st in stmts {
                     lint_stmt(st, out);
                 }
             }
             if let Some(def) = default_body {
+                check_unreachable(def, out);
                 for st in def {
                     lint_stmt(st, out);
                 }
             }
         }
-        Statement::DoWhile { body, .. } => lint_stmt(body, out),
-        Statement::Export { declaration, .. } => {
-            if let tishlang_ast::ExportDeclaration::Named(inner) = declaration.as_ref() {
-                lint_stmt(inner, out);
-            }
+        Statement::DoWhile { body, cond, .. } => {
+            lint_stmt(body, out);
+            lint_expr(cond, out);
         }
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            tishlang_ast::ExportDeclaration::Named(inner) => lint_stmt(inner, out),
+            // 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),
+        },
         Statement::ExprStmt { expr, .. } => lint_expr(expr, out),
         Statement::VarDecl { init: Some(e), .. } => lint_expr(e, out),
         Statement::VarDeclDestructure { init, .. } => lint_expr(init, out),
@@ -126,29 +196,26 @@ fn is_empty_block_or_stmt(s: &Statement) -> bool {
 }
 
 fn stmt_span(s: &Statement) -> (u32, u32) {
-    let sp = match s {
-        Statement::Block { span, .. } => *span,
-        Statement::Try { span, .. } => *span,
-        _ => tishlang_ast::Span {
-            start: (1, 1),
-            end: (1, 1),
-        },
-    };
+    // 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)).
+    let sp = s.span();
     (sp.start.0 as u32, sp.start.1 as u32)
 }
 
 fn lint_expr(e: &Expr, out: &mut Vec<LintDiagnostic>) {
     match e {
-        Expr::Object { props, span, .. } => {
+        Expr::Object { props, .. } => {
             let mut seen: HashSet<&str> = HashSet::new();
             for p in props {
-                if let ObjectProp::KeyValue(k, v) = p {
+                if let ObjectProp::KeyValue(k, v, kspan) = p {
                     if !seen.insert(k.as_ref()) {
+                        // Point at the duplicated KEY, not the enclosing `{` — so distinct dupes get
+                        // distinct positions (#143).
                         out.push(LintDiagnostic {
                             code: "tish-duplicate-key",
                             message: format!("Duplicate object key `{}`", k),
-                            line: span.start.0 as u32,
-                            col: span.start.1 as u32,
+                            line: kspan.start.0 as u32,
+                            col: kspan.start.1 as u32,
                             severity: Severity::Warning,
                         });
                     }
@@ -238,6 +305,8 @@ fn lint_expr(e: &Expr, out: &mut Vec<LintDiagnostic>) {
         }
         Expr::Await { operand, .. } => lint_expr(operand, out),
         Expr::TypeOf { operand, .. } => lint_expr(operand, out),
+        // #142: descend into a delete target (`delete obj[expr]` / `delete (expr).prop`).
+        Expr::Delete { target, .. } => lint_expr(target, out),
         Expr::JsxElement {
             props, children, ..
         } => {
@@ -279,3 +348,110 @@ pub const RULES: &[(&str, &str)] = &[
         "Warns when an object literal repeats the same key.",
     ),
 ];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Count `tish-duplicate-key` diagnostics the linter emits for `src` — a probe for whether the
+    /// linter actually descends into a given position (the dup-key rule fires on any object literal
+    /// the walk reaches).
+    fn dup_keys(src: &str) -> usize {
+        lint_source(src)
+            .expect("parse")
+            .iter()
+            .filter(|d| d.code == "tish-duplicate-key")
+            .count()
+    }
+
+    #[test]
+    fn baseline_dup_key_in_plain_var_is_linted() {
+        assert_eq!(dup_keys("let x = { a: 1, a: 2 }\n"), 1);
+    }
+
+    // #141: comma-separated declarators lower to Statement::Multi, which the linter skipped.
+    #[test]
+    fn lints_inside_comma_declarators() {
+        assert!(
+            dup_keys("let x = { a: 1, a: 2 }, y = 3\n") >= 1,
+            "dup key in a comma-declarator (Statement::Multi) must be linted"
+        );
+    }
+
+    // #140: control-flow CONDITION expressions were never linted (only bodies were walked).
+    #[test]
+    fn lints_inside_control_flow_conditions() {
+        assert!(dup_keys("if ({ a: 1, a: 2 }) {}\n") >= 1, "if condition");
+        assert!(dup_keys("while ({ a: 1, a: 2 }) { break }\n") >= 1, "while condition");
+        assert!(
+            dup_keys("for (let i = 0; ({ a: 1, a: 2 }); i = i + 1) { break }\n") >= 1,
+            "for condition"
+        );
+        assert!(dup_keys("do { break } while ({ a: 1, a: 2 })\n") >= 1, "do-while condition");
+        assert!(
+            dup_keys("switch ({ a: 1, a: 2 }) { case 1: break }\n") >= 1,
+            "switch discriminant"
+        );
+    }
+
+    // #142: the linter never descended into a delete target.
+    #[test]
+    fn lints_inside_delete_target() {
+        assert!(dup_keys("delete ({ a: 1, a: 2 }).a\n") >= 1, "delete target");
+    }
+
+    // #151: the `export default <expr>` subtree was never walked (only `export <named>` was).
+    #[test]
+    fn lints_inside_export_default() {
+        assert!(
+            dup_keys("export default { a: 1, a: 2 }\n") >= 1,
+            "dup key inside `export default` must be linted"
+        );
+    }
+
+    // #152: no-unreachable.
+    fn unreachable(src: &str) -> usize {
+        lint_source(src)
+            .expect("parse")
+            .iter()
+            .filter(|d| d.code == "tish-unreachable-code")
+            .count()
+    }
+
+    #[test]
+    fn flags_code_after_terminator() {
+        assert_eq!(unreachable("fn f() {\n  return 1\n  let x = 2\n}\n"), 1, "after return");
+        assert_eq!(unreachable("fn g() {\n  throw 1\n  g()\n}\n"), 1, "after throw");
+        assert_eq!(
+            unreachable("fn h() {\n  while (true) {\n    break\n    h()\n  }\n}\n"),
+            1,
+            "after break in loop body"
+        );
+    }
+
+    #[test]
+    fn does_not_flag_reachable_or_hoisted() {
+        // Conditional return is NOT a direct-sibling terminator → following code is reachable.
+        assert_eq!(unreachable("fn f(c) {\n  if (c) { return 1 }\n  let x = 2\n}\n"), 0, "conditional");
+        // Function declarations hoist — valid after a return.
+        assert_eq!(unreachable("fn g() {\n  return 1\n  fn helper() { return 2 }\n}\n"), 0, "hoisted fn");
+        // Switch fall-through (no terminator) is intentional.
+        assert_eq!(unreachable("switch (x) {\n  case 1:\n    a()\n  case 2:\n    b()\n}\n"), 0, "fallthrough");
+    }
+}
+
+#[cfg(test)]
+mod dupkey_position_tests {
+    use super::*;
+    #[test]
+    fn dup_key_points_at_the_duplicated_key() {
+        // `let x = { a: 1, a: 2 }` — the duplicate `a` is at 1-indexed col 17; the object `{` is col 9.
+        let d: Vec<_> = lint_source("let x = { a: 1, a: 2 }\n")
+            .expect("parse")
+            .into_iter()
+            .filter(|d| d.code == "tish-duplicate-key")
+            .collect();
+        assert_eq!(d.len(), 1, "exactly one dup-key");
+        assert_eq!((d[0].line, d[0].col), (1, 17), "#143: must point at the duplicated key, not the `{{`");
+    }
+}

package/crates/tish_lsp/Cargo.toml

@@ -23,3 +23,9 @@ tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-std", "tim
 serde_json = "1"
 regex = "1"
 walkdir = "2"
+
+[dev-dependencies]
+# Drive `LspService` over JSON-RPC in tests (#163). Must match the `tower` major that tower-lsp 0.20
+# implements `Service` against (0.4), or the trait bound on `.call()` won't be satisfied. `util`
+# brings in `ServiceExt::ready`.
+tower = { version = "0.4", features = ["util"] }