@tishlang/tish-format 2.12.0 → 2.35.0

package/crates/tish_fmt/src/lib.rs

@@ -613,6 +613,20 @@ impl Printer {
                 self.buf.push_str(") ");
                 self.stmt_inline_or_block(body, level);
             }
+            Statement::ForIn {
+                name,
+                object,
+                body,
+                ..
+            } => {
+                self.indent(level);
+                self.buf.push_str("for (let ");
+                self.buf.push_str(name);
+                self.buf.push_str(" in ");
+                self.expr(object);
+                self.buf.push_str(") ");
+                self.stmt_inline_or_block(body, level);
+            }
             Statement::Return { value, .. } => {
                 self.indent(level);
                 self.buf.push_str("return");
@@ -817,6 +831,43 @@ 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 {
+                            // `export *` always has a source.
+                            self.buf.push_str("* from \"");
+                            self.buf.push_str(from.as_deref().unwrap_or(""));
+                            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(" }");
+                            // #415: a local named export (`export { a }`) has no `from` clause.
+                            if let Some(from) = from {
+                                self.buf.push_str(" from \"");
+                                self.buf.push_str(from);
+                                self.buf.push('"');
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -1127,6 +1178,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 +1457,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 +1943,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