@tishlang/tish 1.0.26 → 1.0.28

package/crates/tish/Cargo.toml

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

package/crates/tish_compile_js/src/codegen.rs

@@ -735,15 +735,14 @@ impl Codegen {
             JsxChild::Text(s) => Ok(format!("{:?}", s.as_ref())),
             JsxChild::Expr(e) => {
                 let inner = self.emit_expr(e)?;
-                let needs_string = !matches!(
+                // Only wrap literals we know are primitives (number, bool, null). Never wrap:
+                // string/template (already strings), JSX (elements), Call (components), Array/Ident (may hold elements).
+                let needs_string = matches!(
                     e,
                     Expr::Literal {
-                        value: Literal::String(_),
+                        value: Literal::Number(_) | Literal::Bool(_) | Literal::Null,
                         ..
                     }
-                    | Expr::TemplateLiteral { .. }
-                    | Expr::JsxElement { .. }
-                    | Expr::JsxFragment { .. }
                 );
                 Ok(if needs_string {
                     format!("String({})", inner)

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -96,4 +96,117 @@ mod tests {
         assert!(js.contains("__vdom_h(\"p\", null, [])"), "{}", &js[..600.min(js.len())]);
         assert!(js.contains("__lattishVdomPatch"));
     }
+
+    /// 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, JsxMode::LattishH).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, JsxMode::LattishH).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, JsxMode::LattishH).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, JsxMode::LattishH).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, JsxMode::LattishH).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, JsxMode::LattishH).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())]
+        );
+    }
 }

package/crates/tish_lexer/src/lib.rs

@@ -14,6 +14,16 @@ use std::str::Chars;
 const INDENT_WIDTH: usize = 2;
 const TAB_AS_LEVELS: usize = 1;
 
+/// One JSX element on the stack: tracks whether we are still in its opening tag (`<Tag ...`)
+/// and how many `{` are open inside that element's **attribute values** (embedded JS).
+/// This lets `>` be a comparison operator inside `{...}` while still closing `<span>` when
+/// `attr_value_braces == 0` for the innermost element (React-like).
+#[derive(Debug, Clone)]
+struct JsxEl {
+    in_opener: bool,
+    attr_value_braces: i32,
+}
+
 #[derive(Debug, Clone)]
 pub struct Lexer<'a> {
     chars: Peekable<Chars<'a>>,
@@ -27,7 +37,7 @@ pub struct Lexer<'a> {
     jsx_after_gt: bool,
     jsx_in_opening_tag: bool,
     jsx_saw_slash_before_gt: bool,
-    jsx_brace_depth: i32,
+    jsx_stack: Vec<JsxEl>,
     jsx_depth: i32,
     jsx_child_brace_depth: i32,
     jsx_in_closing_tag: bool,
@@ -47,13 +57,18 @@ impl<'a> Lexer<'a> {
             jsx_after_gt: false,
             jsx_in_opening_tag: false,
             jsx_saw_slash_before_gt: false,
-            jsx_brace_depth: 0,
+            jsx_stack: Vec::new(),
             jsx_depth: 0,
             jsx_child_brace_depth: 0,
             jsx_in_closing_tag: false,
         }
     }
 
+    #[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);
+    }
+
     fn read_jsx_text(&mut self, start: (usize, usize)) -> Result<Option<Token>, String> {
         let mut s = String::new();
         loop {
@@ -305,18 +320,33 @@ impl<'a> Lexer<'a> {
             '(' => TokenKind::LParen,
             ')' => TokenKind::RParen,
             '{' => {
-                if self.jsx_in_opening_tag { self.jsx_brace_depth += 1; }
-                else if self.jsx_depth > 0 { self.jsx_child_brace_depth += 1; }
+                if self.jsx_in_opening_tag {
+                    if let Some(top) = self.jsx_stack.last_mut() {
+                        top.attr_value_braces += 1;
+                    }
+                } else if self.jsx_depth > 0 {
+                    self.jsx_child_brace_depth += 1;
+                }
                 if let Some(depth) = self.template_brace_stack.last_mut() {
                     *depth += 1;
                 }
                 TokenKind::LBrace
             }
             '}' => {
-                if self.jsx_brace_depth > 0 { self.jsx_brace_depth -= 1; }
-                else if self.jsx_child_brace_depth > 0 {
+                let mut handled = false;
+                if let Some(top) = self.jsx_stack.last() {
+                    if top.in_opener && top.attr_value_braces > 0 {
+                        if let Some(top) = self.jsx_stack.last_mut() {
+                            top.attr_value_braces -= 1;
+                        }
+                        handled = true;
+                    }
+                }
+                if !handled && self.jsx_child_brace_depth > 0 {
                     self.jsx_child_brace_depth -= 1;
-                    if self.jsx_child_brace_depth == 0 { self.jsx_after_gt = true; }
+                    if self.jsx_child_brace_depth == 0 {
+                        self.jsx_after_gt = true;
+                    }
                 }
                 if let Some(depth) = self.template_brace_stack.last_mut() {
                     *depth -= 1;
@@ -358,6 +388,10 @@ impl<'a> Lexer<'a> {
                 else if self.peek() == Some('/') { self.jsx_in_closing_tag = true; TokenKind::Lt }
                 else if self.peek() == Some('>') || self.peek().map(|c| c.is_ascii_alphabetic() || c == '_').unwrap_or(false) {
                     self.jsx_depth += 1;
+                    self.jsx_stack.push(JsxEl {
+                        in_opener: true,
+                        attr_value_braces: 0,
+                    });
                     self.jsx_in_opening_tag = true;
                     TokenKind::Lt
                 } else { TokenKind::Lt }
@@ -366,13 +400,23 @@ impl<'a> Lexer<'a> {
                 if self.peek() == Some('=') { self.advance(); TokenKind::Ge }
                 else if self.peek() == Some('>') { self.advance(); TokenKind::Shr }
                 else {
-                    if self.jsx_in_opening_tag && self.jsx_brace_depth == 0 && !self.jsx_saw_slash_before_gt {
-                        self.jsx_after_gt = true;
-                    }
-                    if self.jsx_in_closing_tag || (self.jsx_in_opening_tag && self.jsx_saw_slash_before_gt) {
+                    if self.jsx_in_closing_tag {
+                        self.jsx_depth = (self.jsx_depth - 1).max(0);
+                        self.jsx_stack.pop();
+                        self.jsx_sync_in_opening_tag();
+                    } else if self.jsx_in_opening_tag && self.jsx_saw_slash_before_gt {
                         self.jsx_depth = (self.jsx_depth - 1).max(0);
+                        self.jsx_stack.pop();
+                        self.jsx_sync_in_opening_tag();
+                    } else if let Some(top) = self.jsx_stack.last_mut() {
+                        if top.in_opener && top.attr_value_braces > 0 {
+                            // `>` is a comparison (or shift) token inside `{ ... }`, not end of opening tag.
+                        } else if top.in_opener && !self.jsx_saw_slash_before_gt {
+                            top.in_opener = false;
+                            self.jsx_after_gt = true;
+                            self.jsx_sync_in_opening_tag();
+                        }
                     }
-                    self.jsx_in_opening_tag = false;
                     self.jsx_in_closing_tag = false;
                     self.jsx_saw_slash_before_gt = false;
                     TokenKind::Gt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, compile to native.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {