@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_compile_js/src/error.rs

@@ -0,0 +1,20 @@
+#[derive(Debug)]
+pub struct CompileError {
+    pub message: String,
+}
+
+impl CompileError {
+    pub fn new(msg: &str) -> Self {
+        Self {
+            message: msg.to_string(),
+        }
+    }
+}
+
+impl std::fmt::Display for CompileError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for CompileError {}

package/crates/tish_compile_js/src/lib.rs

@@ -0,0 +1,26 @@
+//! Tish to JavaScript transpiler backend.
+//! Uses shared resolve from tishlang_compile for unified pipeline.
+
+mod codegen;
+mod error;
+
+#[cfg(test)]
+mod tests_jsx;
+
+pub use codegen::{
+    compile_project_with_jsx, compile_project_with_jsx_and_source_map, compile_with_jsx, JsBundle,
+};
+pub use error::CompileError;
+
+/// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.
+pub fn compile(program: &tishlang_ast::Program, optimize: bool) -> Result<String, CompileError> {
+    compile_with_jsx(program, optimize)
+}
+
+pub fn compile_project(
+    entry_path: &std::path::Path,
+    project_root: Option<&std::path::Path>,
+    optimize: bool,
+) -> Result<String, CompileError> {
+    compile_project_with_jsx(entry_path, project_root, optimize)
+}

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -0,0 +1,414 @@
+#[cfg(test)]
+mod tests {
+    use std::io::Write;
+
+    use tishlang_parser::parse;
+
+    use crate::{compile_project_with_jsx, compile_with_jsx};
+
+    #[test]
+    fn lattish_jsx_emits_h_with_children_array() {
+        let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"),
+            "{}",
+            js
+        );
+        assert!(!js.contains("function __h("));
+    }
+
+    #[test]
+    fn fragment_lattish_uses_fragment_symbol() {
+        let src = "fn X() { return <><b>{\"1\"}</b></> }";
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(js.contains("h(Fragment, null, ["));
+    }
+
+    #[test]
+    fn jsx_keyword_text_after_child_element() {
+        // #108: a text run *after* a nested child element must be lexed as JSX text, so a bare
+        // reserved keyword (`as`, `in`, `if`, `return`, `let`) in that run is plain text, not a
+        // keyword token. Text-only children already worked; the bug was failing to re-enter
+        // JSX-text mode once a child element had closed.
+        for kw in ["as", "in", "if", "return", "let"] {
+            let src = format!("fn V() {{ return <div><span>x</span> {kw} JSON</div> }}");
+            let program =
+                parse(&src).unwrap_or_else(|e| panic!("parse failed for trailing `{kw}`: {e}"));
+            let js = compile_with_jsx(&program, false).unwrap();
+            let expected = format!("[h(\"span\", null, [\"x\"]), \" {kw} JSON\"]");
+            assert!(
+                js.contains(&expected),
+                "trailing `{kw}` after child element: expected {expected:?} in output, got: {js}"
+            );
+        }
+    }
+
+    #[test]
+    fn jsx_text_between_and_after_multiple_children() {
+        // Text both between and after child elements stays text (incl. a keyword run between).
+        let src = r#"fn V() { return <div><span>x</span> as <b>y</b> in z</div> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains(
+                "[h(\"span\", null, [\"x\"]), \" as \", h(\"b\", null, [\"y\"]), \" in z\"]"
+            ),
+            "{js}"
+        );
+    }
+
+    #[test]
+    fn jsx_self_closing_child_then_keyword_text() {
+        // A self-closing child (`<br/>`) followed by keyword text must also re-enter text mode.
+        let src = r#"fn V() { return <div><br/> as JSON</div> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("[h(\"br\", null, []), \" as JSON\"]"),
+            "{js}"
+        );
+    }
+
+    #[test]
+    fn jsx_child_element_inside_expr_container_not_text_mode() {
+        // Re-entering JSX text mode after a child closes must NOT happen when that child lived
+        // inside a `{…}` expression container — otherwise the `)`/`,` that follows is swallowed as
+        // JsxText ("Expected RParen, got JsxText"). Regression for the #108 fix itself, caught by
+        // the downstream suite (tish-audio / tish-midi use `{items.map(x => <li>{x}</li>)}`).
+        let src = r#"fn V(items) { return <ul>{items.map(x => <li>{x}</li>)}</ul> }"#;
+        let program = parse(src).expect("map-in-container must parse");
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(js.contains("h(\"ul\""), "{js}");
+        assert!(js.contains(".map("), "{js}");
+
+        // And the combined case: a `{…}` container followed by trailing keyword text.
+        let src2 = r#"fn V(items) { return <div>{items.map(x => <span>{x}</span>)} as JSON</div> }"#;
+        let program2 = parse(src2).expect("container-then-text must parse");
+        let js2 = compile_with_jsx(&program2, false).unwrap();
+        assert!(js2.contains("\" as JSON\""), "{js2}");
+    }
+
+    #[test]
+    fn jsx_text_whitespace_coalesced() {
+        let src = r#"fn X() { return <p>First paragraph</p> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("\"First paragraph\""),
+            "expected \"First paragraph\" in output, got: {}",
+            &js[..400.min(js.len())]
+        );
+        assert!(
+            !js.contains("\"First\", \"paragraph\""),
+            "text should be coalesced, not split"
+        );
+    }
+
+    #[test]
+    fn jsx_text_whitespace_coalesced_multiline() {
+        let src = "fn App() {\n  return <p>First paragraph</p>\n}";
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("\"First paragraph\""),
+            "multiline: expected \"First paragraph\", got: {}",
+            &js[..400.min(js.len())]
+        );
+    }
+
+    #[test]
+    fn jsx_text_punctuation_no_space() {
+        // Punctuation (e.g. !) concatenates without space: "work!" not "work !"
+        let src = r#"fn X() { return <p>work!</p> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains(r#""work!""#),
+            "expected 'work!', got: {}",
+            &js[..400.min(js.len())]
+        );
+    }
+
+    #[test]
+    fn jsx_text_emojis() {
+        let src = r#"fn X() { return <p>hello 😔</p> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("😔"),
+            "expected emoji, got: {}",
+            &js[..400.min(js.len())]
+        );
+    }
+
+    #[test]
+    fn jsx_text_whitespace_via_compile_project() {
+        let dir = std::env::temp_dir().join("tishlang_compile_project_test");
+        let _ = std::fs::create_dir_all(&dir);
+        let path = dir.join("test.tish");
+        let src = "fn App() {\n  return <p>First paragraph</p>\n}";
+        let mut f = std::fs::File::create(&path).unwrap();
+        f.write_all(src.as_bytes()).unwrap();
+        f.sync_all().unwrap();
+        drop(f);
+        let js = compile_project_with_jsx(&path, Some(&dir), false)
+            .expect("compile_project_with_jsx failed");
+        assert!(
+            js.contains("\"First paragraph\""),
+            "compile_project: expected \"First paragraph\", got: {}",
+            &js[..500.min(js.len())]
+        );
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn jsx_never_emits_vdom_helpers_or_prelude_flags() {
+        let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("h(\"div\", { class: \"x\" }"),
+            "{}",
+            &js[..500.min(js.len())]
+        );
+        assert!(!js.contains("__vdom_h"), "{}", &js[..600.min(js.len())]);
+        assert!(
+            !js.contains("window.__LATTISH_JSX_VDOM"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
+        assert!(
+            !js.contains("__lattishVdomPatch"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
+    }
+
+    /// Component calls like {Panel()} return DOM elements. Wrapping in String() produces [object HTMLDivElement].
+    #[test]
+    fn jsx_component_call_not_wrapped_in_string() {
+        let src = r#"
+fn Panel() { return <div class="p">content</div> }
+fn App() { return <div>{Panel()}</div> }
+"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("Panel()"),
+            "component call should appear as Panel(), got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("String(Panel()"),
+            "component calls must NOT be wrapped in String() - causes [object HTMLDivElement]. got: {}",
+            &js[..600.min(js.len())]
+        );
+    }
+
+    /// Nested JSX elements must not be String()'d or they render as [object HTMLDivElement].
+    #[test]
+    fn jsx_nested_element_not_wrapped_in_string() {
+        let src = r#"fn X() { return <div><span>inner</span></div> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            !js.contains("String(h("),
+            "nested JSX elements must NOT be wrapped in String(). got: {}",
+            &js[..500.min(js.len())]
+        );
+    }
+
+    /// Literal number/bool/null get String() for display. Idents (e.g. {items}) are NOT wrapped—they may hold elements.
+    #[test]
+    fn jsx_literal_number_wrapped_in_string() {
+        let src = r#"fn X() { return <span>{42}</span> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            js.contains("String(42)"),
+            "literal number in JSX should be wrapped in String(). got: {}",
+            &js[..500.min(js.len())]
+        );
+    }
+
+    /// Array/ident like {items} (array of buttons) must NOT be String()'d or we get [object HTMLButtonElement].
+    #[test]
+    fn jsx_array_of_elements_not_wrapped_in_string() {
+        let src = r#"
+fn FileList() {
+  let items = []
+  items.push(<button>a</button>)
+  items.push(<button>b</button>)
+  return <div>{items}</div>
+}
+"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(
+            !js.contains("String(items)"),
+            "array/ident in JSX must NOT be wrapped in String() - causes [object HTMLButtonElement]. got: {}",
+            &js[..600.min(js.len())]
+        );
+    }
+
+    /// `>` inside `{ ... }` attribute values must be a comparison operator, not end of opening tag.
+    #[test]
+    fn jsx_gt_comparison_inside_attribute_expression() {
+        let src = r#"fn X() {
+  return <button
+    type="button"
+    onclick={() => {
+      let nm = "a"
+      if (nm && nm.length > 0) { print(nm) }
+    }}
+  >{"ok"}</button>
+}"#;
+        let program = parse(src).expect("parse multi-line JSX with > comparison in attr");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("length > 0") || js.contains("length>0"),
+            "expected compiled JS to preserve greater-than comparison, got: {}",
+            &js[..800.min(js.len())]
+        );
+    }
+
+    /// Nested JSX inside an attribute callback must still close inner `<tag>` correctly.
+    #[test]
+    fn jsx_nested_element_inside_attribute_expression() {
+        let src = r#"fn X() {
+  return <button
+    onclick={() => {
+      let x = <span>{"inner"}</span>
+      print(x)
+    }}
+  >{"outer"}</button>
+}"#;
+        let program = parse(src).expect("parse nested JSX inside onclick");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("\"inner\""),
+            "expected nested span text in output, got: {}",
+            &js[..900.min(js.len())]
+        );
+        assert!(
+            js.contains("\"outer\""),
+            "expected button child text in output, got: {}",
+            &js[..900.min(js.len())]
+        );
+    }
+
+    #[test]
+    fn new_date_global_emits_valid_js_with_and_without_optimize() {
+        let src = "let epoch = new Date(0)\nconsole.log(epoch.getTime())";
+        let program = parse(src).expect("parse");
+        for optimize in [false, true] {
+            let js = compile_with_jsx(&program, optimize).expect("compile");
+            assert!(
+                js.contains("new Date(0)"),
+                "optimize={optimize}: expected `new Date(0)` in JS output:\n{js}"
+            );
+            assert!(
+                !js.contains("let epoch = new;"),
+                "optimize={optimize}: broken `new` emission (missing constructor):\n{js}"
+            );
+        }
+    }
+
+    #[test]
+    fn new_uint8array_emits_direct_new_no_preamble() {
+        let src = "fn f(n) { return new Uint8Array(n) }";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new Uint8Array("),
+            "expected direct new Uint8Array, got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("__tishUint8Array"),
+            "should not emit legacy intrinsic helper"
+        );
+    }
+
+    #[test]
+    fn new_audio_context_emits_direct_new_no_preamble() {
+        let src = "fn f() { return new AudioContext() }";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new AudioContext("),
+            "expected new AudioContext, got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("__tishWebAudioCreateContext"),
+            "should not emit legacy intrinsic helper"
+        );
+    }
+
+    #[test]
+    fn new_class_name_emits_direct_new_js() {
+        let src = r#"
+fn ClassName(x) {
+    return x
+}
+fn factory() {
+    return new ClassName(42)
+}
+"#;
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new ClassName("),
+            "expected new ClassName( in JS output, got: {}",
+            &js[..800.min(js.len())]
+        );
+    }
+
+    #[test]
+    fn fn_body_two_lets_not_split_by_closing_brace() {
+        let src = "fn h() {\n  let a = 1\n  let b = 2\n}\n";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        let i = js.find("let a = 1").expect("let a");
+        let j = js.find("let b = 2").expect("let b");
+        assert!(
+            !js[i..j].contains('}'),
+            "first let must not end in an inner block before second let (regression #43): {:?}",
+            &js[i..j]
+        );
+    }
+
+    #[test]
+    fn control_flow_wraps_lexical_decl_body_in_block_for_valid_js() {
+        let src = r#"fn f() {
+  if (true)
+    const x = 1
+  while (false)
+    let y = 2
+  for (;;)
+    const z = 3
+  for (const v of [])
+    let w = 4
+}"#;
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        for (label, key, decl) in [
+            ("if", "if (true)", "const x = 1"),
+            ("while", "while (false)", "let y = 2"),
+            ("for", "for (; ; )", "const z = 3"),
+            ("for-of", "for (const v of [])", "let w = 4"),
+        ] {
+            let i = js.find(key).expect(label);
+            let j = js.find(decl).expect(label);
+            assert!(
+                i < j && js[i..j].contains('{'),
+                "{label}: expected '{{' between {key:?} and {decl:?}, got {:?}",
+                &js[i..j]
+            );
+        }
+    }
+}

package/crates/tish_compiler_wasm/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "tishlang_compiler_wasm"
+version = "0.1.0"
+edition = "2021"
+description = "Tish compiler as WASM for browser (parse + bytecode + JS)"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+base64 = "0.22"
+serde_json = "1.0"
+wasm-bindgen = "0.2"
+
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_compile_js = { path = "../tish_compile_js", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+tishlang_parser = { path = "../tish_parser", version = ">=0.1" }

package/crates/tish_compiler_wasm/src/lib.rs

@@ -0,0 +1,57 @@
+//! Tish compiler exposed to JS via wasm-bindgen.
+//! Compiles single source string → bytecode (base64) or JS. Used by playground, REPL, try-it pages.
+//!
+//! `compile_to_js` / `compile_to_js_with_imports` use Lattish-style JSX lowering. Prepend a compiled
+//! **Lattish.tish** runtime (same as playground `lattish-runtime.js`) so the iframe/script scope has
+//! hooks and the JSX helpers; source files do not need to import the JSX helper by name.
+
+mod resolve_virtual;
+
+use base64::Engine;
+use resolve_virtual::{detect_cycles_virtual, merge_modules_virtual, resolve_virtual};
+use std::collections::HashMap;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let program = tishlang_opt::optimize(&program);
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
+}
+
+#[wasm_bindgen]
+pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
+}
+
+#[wasm_bindgen]
+pub fn compile_to_bytecode_with_imports(
+    entry_path: &str,
+    files_json: &str,
+) -> Result<String, JsValue> {
+    let files: HashMap<String, String> = serde_json::from_str(files_json)
+        .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
+    detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
+    let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
+    let program = tishlang_opt::optimize(&program);
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
+}
+
+#[wasm_bindgen]
+pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
+    let files: HashMap<String, String> = serde_json::from_str(files_json)
+        .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
+    detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
+    let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
+    let program = tishlang_opt::optimize(&program);
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
+}