@tishlang/tish 1.9.1 → 1.9.2

package/crates/tish/Cargo.toml

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

package/crates/tish_compile_js/src/codegen.rs

@@ -34,6 +34,29 @@ impl Codegen {
         }
     }
 
+    /// ECMAScript does not allow `if (c) const x = 1` / `while (c) let y = 2` without a block.
+    fn stmt_needs_braces_in_js_control_head(stmt: &Statement) -> bool {
+        matches!(
+            stmt,
+            Statement::VarDecl { .. } | Statement::VarDeclDestructure { .. }
+        )
+    }
+
+    fn emit_js_control_body(&mut self, body: &Statement) -> Result<(), CompileError> {
+        if Self::stmt_needs_braces_in_js_control_head(body) {
+            self.writeln("{");
+            self.indent += 1;
+            self.emit_statement(body)?;
+            self.indent -= 1;
+            self.writeln("}");
+        } else {
+            self.indent += 1;
+            self.emit_statement(body)?;
+            self.indent -= 1;
+        }
+        Ok(())
+    }
+
     fn indent_str(&self) -> String {
         "  ".repeat(self.indent)
     }
@@ -155,22 +178,16 @@ impl Codegen {
             } => {
                 let c = self.emit_expr(cond)?;
                 self.writeln(&format!("if ({})", c));
-                self.indent += 1;
-                self.emit_statement(then_branch)?;
-                self.indent -= 1;
+                self.emit_js_control_body(then_branch)?;
                 if let Some(eb) = else_branch {
                     self.writeln("else");
-                    self.indent += 1;
-                    self.emit_statement(eb)?;
-                    self.indent -= 1;
+                    self.emit_js_control_body(eb)?;
                 }
             }
             Statement::While { cond, body, .. } => {
                 let c = self.emit_expr(cond)?;
                 self.writeln(&format!("while ({})", c));
-                self.indent += 1;
-                self.emit_statement(body)?;
-                self.indent -= 1;
+                self.emit_js_control_body(body)?;
             }
             Statement::For {
                 init,
@@ -179,7 +196,10 @@ impl Codegen {
                 body,
                 ..
             } => {
-                self.write("for (");
+                // Keep the whole `for (...)` on one line with normal statement indentation (do not
+                // mix bare `write("for (")` with `writeln(")")`, which indents `)` on a new line).
+                let mut header = self.indent_str();
+                header.push_str("for (");
                 if let Some(i) = init {
                     match i.as_ref() {
                         Statement::VarDecl {
@@ -192,32 +212,32 @@ impl Codegen {
                             let escaped = Self::escape_ident(name.as_ref());
                             if let Some(e) = opt_init {
                                 let ex = self.emit_expr(e)?;
-                                self.write(&format!("{} {} = {}", decl, escaped, ex));
+                                header.push_str(&format!("{} {} = {}", decl, escaped, ex));
                             } else {
-                                self.write(&format!("{} {}", decl, escaped));
+                                header.push_str(&format!("{} {}", decl, escaped));
                             }
                         }
                         Statement::ExprStmt { expr, .. } => {
                             let ex = self.emit_expr(expr)?;
-                            self.write(&ex);
+                            header.push_str(&ex);
                         }
                         _ => return Err(CompileError::new("Unsupported for init")),
                     }
                 }
-                self.write("; ");
+                header.push_str("; ");
                 if let Some(c) = cond {
                     let ce = self.emit_expr(c)?;
-                    self.write(&ce);
+                    header.push_str(&ce);
                 }
-                self.write("; ");
+                header.push_str("; ");
                 if let Some(u) = update {
                     let ue = self.emit_expr(u)?;
-                    self.write(&ue);
+                    header.push_str(&ue);
                 }
-                self.writeln(")");
-                self.indent += 1;
-                self.emit_statement(body)?;
-                self.indent -= 1;
+                header.push(')');
+                header.push('\n');
+                self.output.push_str(&header);
+                self.emit_js_control_body(body)?;
             }
             Statement::ForOf {
                 name,
@@ -228,9 +248,7 @@ impl Codegen {
                 let escaped = Self::escape_ident(name.as_ref());
                 let it = self.emit_expr(iterable)?;
                 self.writeln(&format!("for (const {} of {})", escaped, it));
-                self.indent += 1;
-                self.emit_statement(body)?;
-                self.indent -= 1;
+                self.emit_js_control_body(body)?;
             }
             Statement::Return { value, .. } => {
                 if let Some(v) = value {

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -303,4 +303,48 @@ fn factory() {
             &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_parser/src/lib.rs

@@ -252,4 +252,78 @@ mod tests {
         parse(SRC).expect("stdlib/builtins.d.tish should parse");
     }
 
+    #[test]
+    fn for_empty_head_parses() {
+        let src = r#"fn f() {
+  for (;;)
+    const x = 1
+}"#;
+        let program = parse(src).expect("for (;;)");
+        let body = match &program.statements[0] {
+            Statement::FunDecl { body, .. } => body,
+            _ => panic!("expected fn"),
+        };
+        let stmts = match body.as_ref() {
+            Statement::Block { statements, .. } => statements,
+            _ => panic!("expected block body"),
+        };
+        assert!(
+            matches!(
+                stmts.iter().find(|s| matches!(s, Statement::For { .. })),
+                Some(Statement::For {
+                    init: None,
+                    cond: None,
+                    update: None,
+                    ..
+                })
+            ),
+            "expected for (;;)"
+        );
+    }
+
+    #[test]
+    fn brace_function_body_does_not_nest_block_around_first_let() {
+        let src = "fn h() {\n  let a = 1\n  let b = 2\n}\n";
+        let program = parse(src).expect("parse");
+        let body = match &program.statements[0] {
+            Statement::FunDecl { body, .. } => body,
+            _ => panic!("expected fn"),
+        };
+        let stmts = match body.as_ref() {
+            Statement::Block { statements, .. } => statements,
+            _ => panic!("expected block body"),
+        };
+        assert_eq!(
+            stmts.len(),
+            2,
+            "expected two top-level lets in fn body, not Block(let) + let — got {stmts:?}"
+        );
+        assert!(matches!(stmts[0], Statement::VarDecl { .. }));
+        assert!(matches!(stmts[1], Statement::VarDecl { .. }));
+    }
+
+    #[test]
+    fn member_access_allows_type_property_name() {
+        let src = "fn f() {\n  const label = 0\n  label.type = \"button\"\n}\n";
+        parse(src).expect("label.type should parse: `type` is a keyword but valid after `.`");
+    }
+
+    #[test]
+    fn brace_block_stmt_then_const_then_if_are_siblings() {
+        let src = "fn g() {\n  f()\n  const x = 1\n  if (x) {\n    f()\n  }\n}\n";
+        let program = parse(src).expect("parse");
+        let body = match &program.statements[0] {
+            Statement::FunDecl { body, .. } => body,
+            _ => panic!("expected fn"),
+        };
+        let stmts = match body.as_ref() {
+            Statement::Block { statements, .. } => statements,
+            _ => panic!("expected block body"),
+        };
+        assert_eq!(stmts.len(), 3, "expected expr; const; if as siblings — got {stmts:?}");
+        assert!(matches!(stmts[0], Statement::ExprStmt { .. }));
+        assert!(matches!(stmts[1], Statement::VarDecl { .. }));
+        assert!(matches!(stmts[2], Statement::If { .. }));
+    }
+
 }

package/crates/tish_parser/src/parser.rs

@@ -99,6 +99,18 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// After `.` / `?.`, allow `type` as a member name (`TokenKind::Type`); see `docs/js-emit-philosophy.md`.
+    fn expect_ident_or_type_member_name(&mut self) -> Result<&Token, String> {
+        match self.peek_kind() {
+            Some(TokenKind::Ident) => self.expect(TokenKind::Ident),
+            Some(TokenKind::Type) => self.expect(TokenKind::Type),
+            other => Err(format!(
+                "Expected property name after `.` or `?.`, got {:?}",
+                other
+            )),
+        }
+    }
+
     fn span_end(&self, start: (usize, usize)) -> Span {
         let end = self.peek().map(|t| t.span.start).unwrap_or(start);
         Span { start, end }
@@ -194,8 +206,17 @@ impl<'a> Parser<'a> {
     fn parse_block(&mut self) -> Result<Statement, String> {
         let span_start = self.peek().ok_or("Unexpected EOF")?.span.start;
 
-        if matches!(self.peek_kind(), Some(TokenKind::LBrace)) {
+        let opened_with_brace = matches!(self.peek_kind(), Some(TokenKind::LBrace));
+        if opened_with_brace {
             self.advance(); // {
+            // After `{`, the lexer often emits `Indent` for the first indented line of the body.
+            // `parse_statement` treats a leading `Indent` as starting a *nested* indent-block, so
+            // without consuming this token we get `Block { Block { let ... } ; ... }` and the first
+            // `let`/`const` is scoped too narrowly (JS ReferenceError). This indent is layout for
+            // *this* brace block, not an inner block.
+            if matches!(self.peek_kind(), Some(TokenKind::Indent)) {
+                self.advance();
+            }
         } else if matches!(self.peek_kind(), Some(TokenKind::Indent)) {
             self.advance(); // Indent
         }
@@ -938,6 +959,11 @@ impl<'a> Parser<'a> {
             self.expect(TokenKind::Semicolon)?;
             Some(c)
         };
+        // `for (init; ; update)` — when the condition is empty we matched `;` above but did not
+        // consume it; skip it so `update` / `)` parse correctly (e.g. `for (;;)`).
+        if cond.is_none() && matches!(self.peek_kind(), Some(TokenKind::Semicolon)) {
+            self.advance();
+        }
         let update = if matches!(self.peek_kind(), Some(TokenKind::RParen)) {
             None
         } else {
@@ -1483,7 +1509,7 @@ impl<'a> Parser<'a> {
                 TokenKind::Dot | TokenKind::OptionalChain => {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
-                    let prop_tok = self.expect(TokenKind::Ident)?;
+                    let prop_tok = self.expect_ident_or_type_member_name()?;
                     let prop = prop_tok
                         .literal
                         .clone()
@@ -1603,7 +1629,7 @@ impl<'a> Parser<'a> {
                 TokenKind::Dot | TokenKind::OptionalChain => {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
-                    let prop_tok = self.expect(TokenKind::Ident)?;
+                    let prop_tok = self.expect_ident_or_type_member_name()?;
                     let prop = prop_tok
                         .literal
                         .clone()
@@ -1997,7 +2023,8 @@ impl<'a> Parser<'a> {
                     self.expect(TokenKind::RBrace)?; // }
                     props.push(JsxProp::Spread(expr));
                 }
-                Some(TokenKind::Ident) => {
+                // `type` is `TokenKind::Type` but valid as a JSX attr name; see docs/js-emit-philosophy.md.
+                Some(TokenKind::Ident) | Some(TokenKind::Type) => {
                     let name_tok = self.advance().unwrap();
                     let name = name_tok.literal.clone().ok_or("Expected attr name")?;
                     if matches!(self.peek_kind(), Some(TokenKind::Assign)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {