@tishlang/tish 2.1.0 → 2.2.3

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.1.0"
+version = "2.2.3"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/main.rs

@@ -56,15 +56,17 @@ fn vm_capabilities_for_cli_run(cli_features: &[String]) -> HashSet<String> {
 
 /// `--feature` list for `tish build --target native`: same default as `tish run` (all linked-in caps).
 fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
-    if cli_features.is_empty() {
-        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
-            .into_iter()
-            .collect();
-        v.sort();
-        v
+    let mut v: Vec<String> = if cli_features.is_empty() {
+        tishlang_vm::all_compiled_capabilities().into_iter().collect()
     } else {
-        cli_features.to_vec()
-    }
+        // Normalize exactly like `tish run`: split comma-separated values (`--feature http,timers`)
+        // and expand `full`. Without this, a value like "http,timers,process" was treated as one
+        // opaque feature name, so `has_feature("http")` was false and the http runtime imports were
+        // never emitted — async `fetch` then failed to compile (issue #209).
+        normalize_capability_flags(cli_features).into_iter().collect()
+    };
+    v.sort();
+    v
 }
 
 /// `tish script.tish` → insert `run` so it matches `tish run script.tish` (npx / npm UX).
@@ -829,6 +831,22 @@ mod cli_tests {
         }
     }
 
+    #[test]
+    fn native_build_features_split_commas_and_expand_full() {
+        use super::native_build_features_from_cli;
+        // Issue #209: a comma-joined value was treated as one opaque feature, so has_feature("http")
+        // was false and the native http imports were skipped (async `fetch` failed to compile).
+        let f = native_build_features_from_cli(&["http,timers,process".to_string()]);
+        for cap in ["http", "timers", "process"] {
+            assert!(f.iter().any(|s| s == cap), "missing `{cap}` in {f:?}");
+        }
+        // `full` expands to every capability, matching `tish run`.
+        let full = native_build_features_from_cli(&["full".to_string()]);
+        for cap in ["http", "timers", "fs", "process", "regex", "ws", "tty"] {
+            assert!(full.iter().any(|s| s == cap), "`full` missing `{cap}` in {full:?}");
+        }
+    }
+
     #[test]
     fn run_stdin_marker_parses_as_file() {
         let cli = Cli::try_parse_from(["tish", "run", "-"]).unwrap();

package/crates/tish/tests/fixtures/read_file_bytes.tish

@@ -0,0 +1,10 @@
+// Fixture for issue #120: read a binary file as a byte array via tish:fs.readFileBytes.
+// The test points RFB_FIXTURE at a file containing non-UTF-8 bytes (NUL, 0xFF, …).
+import { readFileBytes } from "tish:fs"
+import { process } from "tish:process"
+
+let path = process.env.RFB_FIXTURE
+let b = readFileBytes(path)
+console.log("isArray:" + String(Array.isArray(b)))
+console.log("len:" + String(b.length))
+console.log("bytes:" + b.join(","))

package/crates/tish/tests/fs_read_file_bytes.rs

@@ -0,0 +1,45 @@
+//! Issue #120: `tish:fs.readFileBytes` reads a binary file as an array of byte values (0–255)
+//! on every backend, where the UTF-8-only `readFile` cannot. Verifies the exact bytes,
+//! including a NUL and 0xFF (not valid UTF-8).
+
+use std::path::PathBuf;
+use std::process::Command;
+
+const EXPECTED: &str = "\
+isArray:true
+len:7
+bytes:0,1,2,255,128,72,73
+";
+
+fn run(backend: &str, fixture: &str, data_path: &str) -> String {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let out = Command::new(&tish)
+        .args(["run", "--backend", backend, "--feature", "fs,process", fixture])
+        .env("RFB_FIXTURE", data_path)
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out.status.success(),
+        "tish run --backend {backend} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8_lossy(&out.stdout).into_owned()
+}
+
+#[test]
+fn read_file_bytes_reads_binary_on_every_backend() {
+    // A file whose bytes are not valid UTF-8 (NUL, 0xFF, 0x80) — readFile would error on it.
+    let data_path = std::env::temp_dir().join("tish_rfb_fixture.dat");
+    std::fs::write(&data_path, [0u8, 1, 2, 255, 128, 72, 73]).expect("write fixture");
+    let data_path = data_path.to_str().unwrap();
+
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("read_file_bytes.tish");
+    assert!(fixture.is_file(), "missing fixture {}", fixture.display());
+    let fixture = fixture.to_str().unwrap();
+
+    assert_eq!(run("vm", fixture, data_path), EXPECTED, "vm output mismatch");
+    assert_eq!(run("interp", fixture, data_path), EXPECTED, "interp output mismatch");
+}

package/crates/tish_ast/src/ast.rs

@@ -436,6 +436,11 @@ pub enum Expr {
     /// JSX element: <Tag props>children</Tag>
     JsxElement {
         tag: Arc<str>,
+        /// Span of the tag name in the opening tag (`<`**`Foo`**`>`), for go-to-def / rename.
+        tag_span: Span,
+        /// Span of the tag name in the closing tag (`</`**`Foo`**`>`); `None` for self-closing
+        /// (`<Foo/>`). Renaming a component must update both, or `<Bar></Foo>` would be invalid.
+        close_tag_span: Option<Span>,
         props: Vec<JsxProp>,
         children: Vec<JsxChild>,
         span: Span,

package/crates/tish_compile/src/codegen.rs

@@ -1094,6 +1094,7 @@ impl Codegen {
                     "fileExists" => Some("Value::native(|args: &[Value]| tish_file_exists(args))"),
                     "isDir" => Some("Value::native(|args: &[Value]| tish_is_dir(args))"),
                     "readDir" => Some("Value::native(|args: &[Value]| tish_read_dir(args))"),
+                    "readFileBytes" => Some("Value::native(|args: &[Value]| tish_read_file_bytes(args))"),
                     "mkdir" => Some("Value::native(|args: &[Value]| tish_mkdir(args))"),
                     _ => None,
                 },
@@ -1455,7 +1456,7 @@ impl Codegen {
             }
         }
         if self.has_feature("fs") {
-            self.write("use tishlang_runtime::{read_file as tish_read_file, write_file as tish_write_file, file_exists as tish_file_exists, is_dir as tish_is_dir, read_dir as tish_read_dir, mkdir as tish_mkdir};\n");
+            self.write("use tishlang_runtime::{read_file as tish_read_file, read_file_bytes as tish_read_file_bytes, write_file as tish_write_file, file_exists as tish_file_exists, is_dir as tish_is_dir, read_dir as tish_read_dir, mkdir as tish_mkdir};\n");
         }
         if self.has_feature("ws") {
             self.write("use tishlang_runtime::{web_socket_client as tish_ws_client, web_socket_server_construct as tish_ws_server_construct};\n");
@@ -2673,6 +2674,8 @@ impl Codegen {
                     "Set",
                     "Map",
                     "Object",
+                    "Array",
+                    "Number",
                     "Float64Array",
                     "Float32Array",
                     "Int8Array",
@@ -2713,6 +2716,25 @@ impl Codegen {
                         self.writeln(&format!("let {} = {}.clone();", builtin, builtin));
                     }
                 }
+                // Feature-gated globals also move into the closure when referenced.
+                // Clone them only when their capability is actually linked, so we
+                // never emit `let h = h.clone();` for a binding that was never
+                // emitted (e.g. a fn-local named `h` in a program without JSX).
+                let mut gated: Vec<&str> = Vec::new();
+                if self.has_feature("http") {
+                    gated.extend(["fetch", "fetchAll"]);
+                }
+                if self.has_feature("fs") {
+                    gated.extend(["readFile", "writeFile", "fileExists", "isDir", "readDir", "mkdir"]);
+                }
+                if self.program_has_jsx && !self.has_native_ui_host {
+                    gated.extend(["Fragment", "h", "text", "useState", "createRoot"]);
+                }
+                for name in gated {
+                    if referenced.contains(name) {
+                        self.writeln(&format!("let {} = {}.clone();", name, name));
+                    }
+                }
                 self.writeln("Value::native(move |args: &[Value]| {");
                 self.value_fn_depth += 1;
                 self.indent += 1;

package/crates/tish_eval/src/eval.rs

@@ -916,6 +916,10 @@ impl Evaluator {
                     exports.insert("fileExists".into(), Value::Native(natives::file_exists));
                     exports.insert("isDir".into(), Value::Native(natives::is_dir));
                     exports.insert("readDir".into(), Value::Native(natives::read_dir));
+                    exports.insert(
+                        "readFileBytes".into(),
+                        Value::Native(natives::read_file_bytes),
+                    );
                     exports.insert("mkdir".into(), Value::Native(natives::mkdir));
                     Ok(Value::object(exports))
                 }

package/crates/tish_eval/src/natives.rs

@@ -420,6 +420,22 @@ pub fn read_file(args: &[Value]) -> Result<Value, String> {
     }
 }
 
+/// Read a file as raw bytes (array of numbers 0–255) for binary data that `read_file`
+/// (UTF-8 only) can't handle. See issue #120.
+#[cfg(feature = "fs")]
+pub fn read_file_bytes(args: &[Value]) -> Result<Value, String> {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    match std::fs::read(&path) {
+        Ok(bytes) => {
+            let items: Vec<Value> = bytes.into_iter().map(|b| Value::Number(b as f64)).collect();
+            Ok(Value::Array(Rc::new(RefCell::new(items))))
+        }
+        Err(e) => Ok(Value::String(format!("Error: {}", e).into())),
+    }
+}
+
 #[cfg(feature = "fs")]
 pub fn write_file(args: &[Value]) -> Result<Value, String> {
     let path = args.first().map(|v| v.to_string()).unwrap_or_default();

package/crates/tish_fmt/src/lib.rs

@@ -1124,11 +1124,41 @@ 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 `{ }`.
+    fn jsx_children(&mut self, children: &[JsxChild]) {
+        for ch in children {
+            match ch {
+                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
+                JsxChild::Expr(e) => {
+                    if matches!(e, Expr::JsxElement { .. } | Expr::JsxFragment { .. }) {
+                        self.expr(e);
+                    } else {
+                        self.buf.push('{');
+                        self.expr(e);
+                        self.buf.push('}');
+                    }
+                }
+            }
+        }
+    }
+
     fn expr(&mut self, e: &Expr) {
         match e {
             Expr::Literal { value, .. } => match value {
                 Literal::Number(n) => {
-                    if n.fract() == 0.0 && n.abs() < 1e15 {
+                    if !n.is_finite() {
+                        // f64 overflow / NaN: emit the tish globals, not Rust's bare `inf`/`-inf`/`NaN`
+                        // (`inf` would re-parse as an undefined identifier).
+                        self.buf.push_str(if n.is_nan() {
+                            "NaN"
+                        } else if *n > 0.0 {
+                            "Infinity"
+                        } else {
+                            "-Infinity"
+                        });
+                    } else if n.fract() == 0.0 && n.abs() < 1e15 {
                         self.buf.push_str(&format!("{}", *n as i64));
                     } else {
                         self.buf.push_str(&format!("{}", n));
@@ -1169,7 +1199,18 @@ impl Printer {
             }
             Expr::New { callee, args, .. } => {
                 self.buf.push_str("new ");
-                self.child(callee, PREC_POSTFIX);
+                // `new` parses its callee as a member expression WITHOUT a trailing call, so any call
+                // in the callee's spine (`new (factory())()`, `new (factory().Cls)()`) must be
+                // parenthesized — otherwise the printed `()` rebinds as the constructor's argument
+                // list. child()'s precedence check can't catch this because a Call/Member already has
+                // postfix precedence.
+                if new_callee_has_call(callee) {
+                    self.buf.push('(');
+                    self.expr(callee);
+                    self.buf.push(')');
+                } else {
+                    self.child(callee, PREC_POSTFIX);
+                }
                 if !args.is_empty() {
                     self.emit_args(args);
                 }
@@ -1370,72 +1411,21 @@ impl Printer {
                 if children.is_empty() {
                     self.buf.push_str(" />");
                 } else {
-                    let compact = children.len() == 1
-                        && matches!(
-                            &children[0],
-                            JsxChild::Text(t) if !t.as_ref().contains('\n')
-                        );
-                    if compact {
-                        self.buf.push('>');
-                        if let JsxChild::Text(t) = &children[0] {
-                            self.buf.push_str(t.as_ref());
-                        }
-                        self.buf.push_str("</");
-                        self.buf.push_str(tag.as_ref());
-                        self.buf.push('>');
-                    } else {
-                        self.buf.push('>');
-                        self.buf.push('\n');
-                        for ch in children {
-                            self.buf.push_str("  ");
-                            match ch {
-                                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
-                                JsxChild::Expr(e) => {
-                                    self.buf.push('{');
-                                    self.expr(e);
-                                    self.buf.push('}');
-                                }
-                            }
-                            self.buf.push('\n');
-                        }
-                        self.buf.push_str("  </");
-                        self.buf.push_str(tag.as_ref());
-                        self.buf.push('>');
-                    }
+                    // JSX whitespace is significant in tish (the lexer keeps it verbatim and codegen
+                    // emits it as content), so children are printed inline and verbatim. Reflowing
+                    // them onto indented lines injected newlines/spaces as real text nodes, which
+                    // changed the rendered output and was non-idempotent.
+                    self.buf.push('>');
+                    self.jsx_children(children);
+                    self.buf.push_str("</");
+                    self.buf.push_str(tag.as_ref());
+                    self.buf.push('>');
                 }
             }
             Expr::JsxFragment { children, .. } => {
                 self.buf.push_str("<>");
-                if children.is_empty() {
-                    self.buf.push_str("</>");
-                } else {
-                    let compact = children.len() == 1
-                        && matches!(
-                            &children[0],
-                            JsxChild::Text(t) if !t.as_ref().contains('\n')
-                        );
-                    if compact {
-                        if let JsxChild::Text(t) = &children[0] {
-                            self.buf.push_str(t.as_ref());
-                        }
-                        self.buf.push_str("</>");
-                    } else {
-                        self.buf.push('\n');
-                        for ch in children {
-                            self.buf.push_str("  ");
-                            match ch {
-                                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
-                                JsxChild::Expr(e) => {
-                                    self.buf.push('{');
-                                    self.expr(e);
-                                    self.buf.push('}');
-                                }
-                            }
-                            self.buf.push('\n');
-                        }
-                        self.buf.push_str("</>");
-                    }
-                }
+                self.jsx_children(children);
+                self.buf.push_str("</>");
             }
             Expr::NativeModuleLoad {
                 spec, export_name, ..
@@ -1466,9 +1456,19 @@ impl Printer {
 }
 
 fn escape_template(s: &str) -> String {
-    s.replace('\\', "\\\\")
-        .replace('`', "\\`")
-        .replace('$', "\\$")
+    // In a template literal only backslash, backtick, and a `$` that begins an interpolation (`${`)
+    // need escaping. A bare `$` is literal, so escaping every `$` just adds spurious backslashes.
+    let mut out = String::with_capacity(s.len());
+    let mut chars = s.chars().peekable();
+    while let Some(c) = chars.next() {
+        match c {
+            '\\' => out.push_str("\\\\"),
+            '`' => out.push_str("\\`"),
+            '$' if chars.peek() == Some(&'{') => out.push_str("\\$"),
+            _ => out.push(c),
+        }
+    }
+    out
 }
 
 // Expression precedence levels (higher binds tighter), mirroring the parser's
@@ -1528,16 +1528,29 @@ fn expr_prec(e: &Expr) -> u8 {
         | Expr::PrefixInc { .. }
         | Expr::PrefixDec { .. } => 14,
         Expr::Call { .. }
-        | Expr::New { .. }
         | Expr::Member { .. }
         | Expr::Index { .. }
         | Expr::PostfixInc { .. }
         | Expr::PostfixDec { .. } => PREC_POSTFIX,
+        // `new X` binds looser than member/call, so a New used as the object of `.`/`[]`/`()`
+        // must be parenthesized (e.g. `(new Foo()).bar()`, not `new Foo().bar()`).
+        Expr::New { .. } => PREC_POSTFIX - 1,
         Expr::ArrowFunction { .. } => PREC_ATOM,
         _ => PREC_ATOM,
     }
 }
 
+/// True when a `new` callee contains a call in its member/index spine. Such a callee must be
+/// parenthesized, because `new` parses its callee without a trailing call and would otherwise bind
+/// the first `()` as the constructor's argument list (`new (f())()`, `new (f().C)()`).
+fn new_callee_has_call(e: &Expr) -> bool {
+    match e {
+        Expr::Call { .. } => true,
+        Expr::Member { object, .. } | Expr::Index { object, .. } => new_callee_has_call(object),
+        _ => false,
+    }
+}
+
 fn binop(op: BinOp) -> &'static str {
     match op {
         BinOp::Add => "+",
@@ -1813,15 +1826,83 @@ mod tests {
         let _ = tishlang_parser::parse(&out).unwrap();
     }
 
+    /// Debug-render the parsed AST with all `Span { … }` contents removed, so two programs compare
+    /// equal iff they are structurally identical (reformatting legitimately changes spans).
+    fn structure(src: &str) -> String {
+        let dbg = format!("{:#?}", tishlang_parser::parse(src).unwrap().statements);
+        let mut out = String::new();
+        let mut rest = dbg.as_str();
+        while let Some(i) = rest.find("Span {") {
+            out.push_str(&rest[..i]);
+            match rest[i..].find('}') {
+                Some(j) => rest = &rest[i + j + 1..],
+                None => {
+                    rest = "";
+                    break;
+                }
+            }
+        }
+        out.push_str(rest);
+        out
+    }
+
+    #[test]
+    fn new_expr_preserves_structure_and_is_idempotent() {
+        // Each input must format to a program with the SAME structure (modulo spans), and a second
+        // format pass must be a no-op. These previously corrupted into structurally different
+        // programs (Call<->New<->Member swaps) on format.
+        for src in [
+            "const d = (new Foo()).bar()\n",
+            "const b = new (factory().Cls)()\n",
+            "const x = new (getClass())(1)\n",
+            "const e = new Foo()\n",
+            "const f = new a.b.c()\n",
+            "const g = new Foo(1, 2).baz\n",
+        ] {
+            let out = format_source(src).unwrap();
+            let out2 = format_source(&out).unwrap();
+            assert_eq!(structure(src), structure(&out), "structure changed: {src:?} -> {out:?}");
+            assert_eq!(out, out2, "not idempotent: {src:?} -> {out:?} -> {out2:?}");
+        }
+    }
+
+    #[test]
+    fn jsx_preserves_structure_and_is_idempotent() {
+        // JSX whitespace is significant; formatting must not inject newlines/indentation as text
+        // (which changed rendered output and was non-idempotent). Structure must be preserved.
+        for src in [
+            "let x = <div>a{b}</div>\n",
+            "const e = <div>Hello {name}!</div>\n",
+            "const e2 = <div><span>a</span><span>b</span></div>\n",
+            "let y = <div>  spaced  text  </div>\n",
+            "let z = <>{a}{b}</>\n",
+            "let s = <div a={1} b=\"x\">{c}</div>\n",
+        ] {
+            let out = format_source(src).unwrap();
+            let out2 = format_source(&out).unwrap();
+            assert_eq!(structure(src), structure(&out), "JSX structure changed: {src:?} -> {out:?}");
+            assert_eq!(out, out2, "JSX not idempotent: {src:?} -> {out:?} -> {out2:?}");
+        }
+    }
+
     #[test]
-    fn jsx_multiline_when_mixed_children() {
-        let src = "let x = <div>a{b}</div>\n";
+    fn non_finite_number_literal_emits_valid_token() {
+        // 1e400 overflows f64 to infinity; it must format to the `Infinity` global, not Rust's bare
+        // `inf` (which would re-parse as an undefined identifier).
+        let src = "let x = 1e400\n";
         let out = format_source(src).unwrap();
-        assert!(
-            out.contains('\n'),
-            "expected line breaks in formatted JSX: {out:?}"
-        );
-        let _ = tishlang_parser::parse(&out).unwrap();
+        assert!(out.contains("Infinity"), "expected Infinity, got {out:?}");
+        tishlang_parser::parse(&out).expect("formatted output must parse");
+        assert_eq!(format_source(&out).unwrap(), out, "not idempotent: {out:?}");
+    }
+
+    #[test]
+    fn template_literal_escapes_only_interpolation_dollar() {
+        let src = "let p = `cost: $5 and ${x} done`\n";
+        let out = format_source(src).unwrap();
+        assert!(out.contains("cost: $5"), "a bare $ must not be escaped: {out:?}");
+        assert_eq!(structure(src), structure(&out), "structure changed: {src:?} -> {out:?}");
+        assert_eq!(format_source(&out).unwrap(), out, "not idempotent: {out:?}");
     }
 
     #[test]

package/crates/tish_lsp/src/import_goto.rs

@@ -450,6 +450,21 @@ fn resolve_relative_tish(from_dir: &Path, from_s: &str, imported: &str) -> Optio
     crate::find_export(&prog, imported, &u, &src)
 }
 
+/// Resolve a relative default import (`import X from "./m"`) to the `export default` in the source.
+fn resolve_relative_tish_default(from_dir: &Path, from_s: &str) -> Option<Location> {
+    let target = from_dir.join(from_s.trim_start_matches("./"));
+    let target = if target.extension().is_none() {
+        target.with_extension("tish")
+    } else {
+        target
+    };
+    let can = target.canonicalize().ok()?;
+    let u = Url::from_file_path(&can).ok()?;
+    let src = std::fs::read_to_string(&can).ok()?;
+    let prog = tishlang_parser::parse(&src).ok()?;
+    crate::find_default_export(&prog, &u, &src)
+}
+
 /// After same-file [`tishlang_resolve::definition_span`] misses, resolve import sites (Tish files,
 /// `node_modules` packages, and Rust `pub fn` for native / `cargo:` imports).
 pub fn definition_for_import(
@@ -474,12 +489,13 @@ pub fn definition_for_import(
         };
         let from_s = from.as_ref();
         for sp in specifiers {
-            let (imported, local) = match sp {
+            let (imported, local, is_default) = match sp {
                 ImportSpecifier::Named { name, alias, .. } => (
                     name.as_ref(),
                     alias.as_ref().map(|a| a.as_ref()).unwrap_or(name.as_ref()),
+                    false,
                 ),
-                ImportSpecifier::Default { name, .. } => (name.as_ref(), name.as_ref()),
+                ImportSpecifier::Default { name, .. } => (name.as_ref(), name.as_ref(), true),
                 ImportSpecifier::Namespace { .. } => continue,
             };
             if local != word {
@@ -487,7 +503,13 @@ pub fn definition_for_import(
             }
 
             if from_s.starts_with("./") || from_s.starts_with("../") {
-                return resolve_relative_tish(from_dir, from_s, imported);
+                // A default import binds the source module's `export default`, which has no name to
+                // match; resolve it directly. Named imports resolve by exported name.
+                return if is_default {
+                    resolve_relative_tish_default(from_dir, from_s)
+                } else {
+                    resolve_relative_tish(from_dir, from_s, imported)
+                };
             }
 
             if is_native_import(from_s) {