@tishlang/tish 1.0.22 → 1.0.26

package/crates/tish/Cargo.toml

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

package/crates/tish_bytecode/src/peephole.rs

@@ -133,11 +133,7 @@ fn chain_jumps(code: &mut [u8]) {
                 if let Some(final_target) = final_jump_target(code, ip) {
                     if final_target != current_target {
                         let new_offset = final_target as i32 - (ip + 3) as i32;
-                        let bytes = (new_offset as i16).to_be_bytes();
-                        if ip + 2 < code.len() {
-                            code[ip + 1] = bytes[0];
-                            code[ip + 2] = bytes[1];
-                        }
+                        write_u16(code, ip + 1, (new_offset as i16) as u16);
                     }
                 }
             }

package/crates/tish_compile_js/src/codegen.rs

@@ -733,7 +733,24 @@ impl Codegen {
     fn emit_jsx_child(&mut self, child: &JsxChild) -> Result<String, CompileError> {
         match child {
             JsxChild::Text(s) => Ok(format!("{:?}", s.as_ref())),
-            JsxChild::Expr(e) => self.emit_expr(e),
+            JsxChild::Expr(e) => {
+                let inner = self.emit_expr(e)?;
+                let needs_string = !matches!(
+                    e,
+                    Expr::Literal {
+                        value: Literal::String(_),
+                        ..
+                    }
+                    | Expr::TemplateLiteral { .. }
+                    | Expr::JsxElement { .. }
+                    | Expr::JsxFragment { .. }
+                );
+                Ok(if needs_string {
+                    format!("String({})", inner)
+                } else {
+                    inner
+                })
+            }
         }
     }
 }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -51,6 +51,23 @@ mod tests {
         );
     }
 
+    #[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, JsxMode::LattishH).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, JsxMode::LattishH).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");

package/crates/tish_lexer/src/lib.rs

@@ -24,6 +24,13 @@ pub struct Lexer<'a> {
     at_line_start: bool,
     pending_dedents: VecDeque<Token>,
     template_brace_stack: Vec<usize>,
+    jsx_after_gt: bool,
+    jsx_in_opening_tag: bool,
+    jsx_saw_slash_before_gt: bool,
+    jsx_brace_depth: i32,
+    jsx_depth: i32,
+    jsx_child_brace_depth: i32,
+    jsx_in_closing_tag: bool,
 }
 
 impl<'a> Lexer<'a> {
@@ -37,6 +44,29 @@ impl<'a> Lexer<'a> {
             at_line_start: true,
             pending_dedents: VecDeque::new(),
             template_brace_stack: Vec::new(),
+            jsx_after_gt: false,
+            jsx_in_opening_tag: false,
+            jsx_saw_slash_before_gt: false,
+            jsx_brace_depth: 0,
+            jsx_depth: 0,
+            jsx_child_brace_depth: 0,
+            jsx_in_closing_tag: false,
+        }
+    }
+
+    fn read_jsx_text(&mut self, start: (usize, usize)) -> Result<Option<Token>, String> {
+        let mut s = String::new();
+        loop {
+            match self.peek() {
+                None | Some('{') | Some('<') => break,
+                Some(c) => { self.advance(); s.push(c); }
+            }
+        }
+        if s.is_empty() {
+            Ok(None)
+        } else {
+            let end = self.span_start();
+            Ok(Some(Token { kind: TokenKind::JsxText, span: Span { start, end }, literal: Some(s.into()) }))
         }
     }
 
@@ -227,6 +257,16 @@ impl<'a> Lexer<'a> {
             return Ok(Some(tok));
         }
 
+        if self.jsx_after_gt {
+            self.jsx_after_gt = false;
+            if !matches!(self.peek(), Some('{') | Some('<') | None) {
+                let start = self.span_start();
+                if let Some(tok) = self.read_jsx_text(start)? {
+                    return Ok(Some(tok));
+                }
+            }
+        }
+
         if self.at_line_start {
             self.at_line_start = false;
             let level = self.read_indent_level();
@@ -265,10 +305,19 @@ impl<'a> Lexer<'a> {
             '(' => TokenKind::LParen,
             ')' => TokenKind::RParen,
             '{' => {
-                if let Some(depth) = self.template_brace_stack.last_mut() { *depth += 1; }
+                if self.jsx_in_opening_tag { self.jsx_brace_depth += 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 {
+                    self.jsx_child_brace_depth -= 1;
+                    if self.jsx_child_brace_depth == 0 { self.jsx_after_gt = true; }
+                }
                 if let Some(depth) = self.template_brace_stack.last_mut() {
                     *depth -= 1;
                     if *depth == 0 {
@@ -306,12 +355,28 @@ impl<'a> Lexer<'a> {
             '<' => {
                 if self.peek() == Some('=') { self.advance(); TokenKind::Le }
                 else if self.peek() == Some('<') { self.advance(); TokenKind::Shl }
-                else { TokenKind::Lt }
+                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_in_opening_tag = true;
+                    TokenKind::Lt
+                } else { TokenKind::Lt }
             }
             '>' => {
                 if self.peek() == Some('=') { self.advance(); TokenKind::Ge }
                 else if self.peek() == Some('>') { self.advance(); TokenKind::Shr }
-                else { TokenKind::Gt }
+                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) {
+                        self.jsx_depth = (self.jsx_depth - 1).max(0);
+                    }
+                    self.jsx_in_opening_tag = false;
+                    self.jsx_in_closing_tag = false;
+                    self.jsx_saw_slash_before_gt = false;
+                    TokenKind::Gt
+                }
             }
             '^' => TokenKind::BitXor,
             '~' => TokenKind::BitNot,
@@ -334,7 +399,10 @@ impl<'a> Lexer<'a> {
                 if self.peek() == Some('/') { self.advance(); self.skip_line_comment(); return self.next_token(); }
                 else if self.peek() == Some('*') { self.advance(); self.skip_block_comment()?; return self.next_token(); }
                 else if self.peek() == Some('=') { self.advance(); TokenKind::SlashAssign }
-                else { TokenKind::Slash }
+                else {
+                    if self.jsx_in_opening_tag { self.jsx_saw_slash_before_gt = true; }
+                    TokenKind::Slash
+                }
             }
             '%' => {
                 if self.peek() == Some('=') { self.advance(); TokenKind::PercentAssign }

package/crates/tish_lexer/src/token.rs

@@ -115,6 +115,8 @@ pub enum TokenKind {
     TemplateHead,    // `text${  (start with interpolation)
     TemplateMiddle,  // }text${  (middle part)
     TemplateTail,    // }text`   (end part)
+
+    JsxText,  // Raw text in JSX children (emojis, etc.); only {}<> are special
 }
 
 impl TokenKind {

package/crates/tish_parser/src/parser.rs

@@ -1561,10 +1561,54 @@ impl<'a> Parser<'a> {
         })
     }
 
-    /// Push text child, merging with previous Text if any (preserves spaces between tokens).
-    fn push_or_merge_text(&self, children: &mut Vec<JsxChild>, s: Arc<str>) {
+    fn token_as_jsx_text(kind: TokenKind) -> Option<&'static str> {
+        use TokenKind::*;
+        match kind {
+            Not => Some("!"),
+            Question => Some("?"),
+            Dot => Some("."),
+            Comma => Some(","),
+            Colon => Some(":"),
+            Semicolon => Some(";"),
+            Plus => Some("+"),
+            Minus => Some("-"),
+            Star => Some("*"),
+            Slash => Some("/"),
+            Percent => Some("%"),
+            Eq | Assign => Some("="),
+            Gt => Some(">"),
+            Le => Some("<="),
+            Ge => Some(">="),
+            Ne => Some("!="),
+            StrictEq => Some("==="),
+            StrictNe => Some("!=="),
+            BitAnd => Some("&"),
+            BitOr => Some("|"),
+            BitXor => Some("^"),
+            BitNot => Some("~"),
+            And => Some("&&"),
+            Or => Some("||"),
+            LParen => Some("("),
+            RParen => Some(")"),
+            LBracket => Some("["),
+            RBracket => Some("]"),
+            PlusPlus => Some("++"),
+            MinusMinus => Some("--"),
+            StarStar => Some("**"),
+            Arrow => Some("=>"),
+            OptionalChain => Some("?."),
+            NullishCoalesce => Some("??"),
+            Shl => Some("<<"),
+            Shr => Some(">>"),
+            _ => None,
+        }
+    }
+
+    /// Merge text. Add space between words (Ident/Number/String); no space before/after punctuation.
+    fn push_or_merge_text(&self, children: &mut Vec<JsxChild>, s: Arc<str>, is_punctuation: bool) {
         if let Some(JsxChild::Text(prev)) = children.last() {
-            let merged = format!("{} {}", prev.as_ref(), s.as_ref());
+            let sep = if is_punctuation { "" } else { " " };
+            let merged = format!("{}{}{}", prev.as_ref(), sep, s.as_ref());
             let last = children.len() - 1;
             children[last] = JsxChild::Text(Arc::from(merged.as_str()));
         } else {
@@ -1608,23 +1652,41 @@ impl<'a> Parser<'a> {
                     self.expect(TokenKind::RBrace)?; // }
                     children.push(JsxChild::Expr(expr));
                 }
+                Some(TokenKind::JsxText) => {
+                    let t = self.advance().unwrap();
+                    let s = t.literal.clone().unwrap_or_default();
+                    if !s.is_empty() {
+                        self.push_or_merge_text(&mut children, s, false);
+                    }
+                }
                 Some(TokenKind::String) => {
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        self.push_or_merge_text(&mut children, s);
+                        self.push_or_merge_text(&mut children, s, false);
+                    }
+                }
+                Some(TokenKind::Number) => {
+                    let t = self.advance().unwrap();
+                    let s = t.literal.clone().unwrap_or_default();
+                    if !s.is_empty() {
+                        self.push_or_merge_text(&mut children, s, false);
                     }
                 }
                 Some(TokenKind::Ident) => {
-                    // Bare identifiers in JSX are text (e.g. "hello" in <div>hello</div>)
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        self.push_or_merge_text(&mut children, s);
+                        self.push_or_merge_text(&mut children, s, false);
                     }
                 }
-                _ => {
-                    return Err(format!("Unexpected token in JSX children: {:?}", self.peek_kind()));
+                Some(k) => {
+                    if let Some(s) = Self::token_as_jsx_text(k) {
+                        self.advance();
+                        self.push_or_merge_text(&mut children, Arc::from(s), true);
+                    } else {
+                        return Err(format!("Unexpected token in JSX children: {:?}", k));
+                    }
                 }
             }
         }
@@ -1666,21 +1728,42 @@ impl<'a> Parser<'a> {
                     self.expect(TokenKind::RBrace)?;
                     children.push(JsxChild::Expr(expr));
                 }
+                Some(TokenKind::JsxText) => {
+                    let t = self.advance().unwrap();
+                    let s = t.literal.clone().unwrap_or_default();
+                    if !s.is_empty() {
+                        self.push_or_merge_text(&mut children, s, false);
+                    }
+                }
                 Some(TokenKind::String) => {
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        self.push_or_merge_text(&mut children, s);
+                        self.push_or_merge_text(&mut children, s, false);
+                    }
+                }
+                Some(TokenKind::Number) => {
+                    let t = self.advance().unwrap();
+                    let s = t.literal.clone().unwrap_or_default();
+                    if !s.is_empty() {
+                        self.push_or_merge_text(&mut children, s, false);
                     }
                 }
                 Some(TokenKind::Ident) => {
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        self.push_or_merge_text(&mut children, s);
+                        self.push_or_merge_text(&mut children, s, false);
+                    }
+                }
+                Some(k) => {
+                    if let Some(s) = Self::token_as_jsx_text(k) {
+                        self.advance();
+                        self.push_or_merge_text(&mut children, Arc::from(s), true);
+                    } else {
+                        return Err(format!("Unexpected token in JSX fragment: {:?}", k));
                     }
                 }
-                _ => return Err(format!("Unexpected token in JSX fragment: {:?}", self.peek_kind())),
             }
         }
     }

package/package.json

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