@tishlang/tish 1.9.1 → 1.10.0

package/crates/tish_native/src/lib.rs

@@ -14,6 +14,22 @@ mod build;
 use std::path::Path;
 use tishlang_ast::Program;
 
+/// Features for the embeddable VM (`cranelift` / `llvm` backends): merge CLI capability flags
+/// (same set as `tish run` / `tish build --target native`) with features inferred from
+/// `import … from 'tish:…'`. Programs that use globals only (`Promise`, `fetch`, `setTimeout`)
+/// still need the former so [`tishlang_cranelift_runtime`] links `tishlang_vm` with matching gates.
+fn merged_embed_runtime_features(cli: &[String], program: &Program) -> Vec<String> {
+    let mut out = cli.to_vec();
+    for f in tishlang_compile::extract_native_import_features(program) {
+        if !out.contains(&f) {
+            out.push(f);
+        }
+    }
+    out.sort();
+    out.dedup();
+    out
+}
+
 /// Error from native compilation.
 #[derive(Debug)]
 pub struct NativeError {
@@ -93,8 +109,8 @@ pub fn compile_to_native(
                 let prog = tishlang_compile::merge_modules(modules)
                     .map(|m| m.program)
                     .map_err(|e| NativeError {
-                    message: e.to_string(),
-                })?;
+                        message: e.to_string(),
+                    })?;
                 if optimize {
                     tishlang_opt::optimize(&prog)
                 } else {
@@ -118,7 +134,7 @@ pub fn compile_to_native(
                 })?
             };
 
-            let cranelift_features = tishlang_compile::extract_native_import_features(&program);
+            let cranelift_features = merged_embed_runtime_features(features, &program);
             tishlang_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
                 .map_err(|e| NativeError {
                     message: e.to_string(),
@@ -138,8 +154,8 @@ pub fn compile_to_native(
                 let prog = tishlang_compile::merge_modules(modules)
                     .map(|m| m.program)
                     .map_err(|e| NativeError {
-                    message: e.to_string(),
-                })?;
+                        message: e.to_string(),
+                    })?;
                 if optimize {
                     tishlang_opt::optimize(&prog)
                 } else {
@@ -160,7 +176,7 @@ pub fn compile_to_native(
                     message: e.to_string(),
                 })?
             };
-            let llvm_features = tishlang_compile::extract_native_import_features(&program);
+            let llvm_features = merged_embed_runtime_features(features, &program);
             tishlang_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)
                 .map_err(|e| NativeError { message: e.message })
         }
@@ -249,7 +265,7 @@ pub fn compile_program_to_native(
                     message: e.to_string(),
                 })?
             };
-            let cranelift_features = tishlang_compile::extract_native_import_features(&program);
+            let cranelift_features = merged_embed_runtime_features(features, &program);
             tishlang_cranelift::compile_chunk_to_native(&chunk, output_path, &cranelift_features)
                 .map_err(|e| NativeError {
                     message: e.to_string(),
@@ -275,13 +291,81 @@ pub fn compile_program_to_native(
                     message: e.to_string(),
                 })?
             };
-            let llvm_features = tishlang_compile::extract_native_import_features(&program);
+            let llvm_features = merged_embed_runtime_features(features, &program);
             tishlang_llvm::compile_chunk_to_native(&chunk, output_path, &llvm_features)
                 .map_err(|e| NativeError { message: e.message })
         }
     }
 }
 
+/// Compile multiple entry `.tish` files to native binaries in **one** nested Cargo build.
+///
+/// Intended for integration tests and batch tooling; keeps production [`compile_to_native`] behavior
+/// unchanged when `TISH_FAST_NATIVE_BUILD` is unset.
+pub fn compile_many_to_native(
+    entries: &[(&Path, &Path)],
+    project_root: Option<&Path>,
+    features: &[String],
+    optimize: bool,
+) -> Result<(), NativeError> {
+    let mut bins: Vec<(String, String, Option<String>)> = Vec::with_capacity(entries.len());
+    let mut merged_native_modules: Vec<tishlang_compile::ResolvedNativeModule> = Vec::new();
+    let mut merged_features: Vec<String> = features.to_vec();
+    let mut merged_extra_deps = String::new();
+    let mut needs_tokio = false;
+    let mut needs_ui = false;
+
+    for (entry_path, _) in entries {
+        let (rust_code, native_modules, effective_features, native_build) =
+            tishlang_compile::compile_project_full(entry_path, project_root, features, optimize)
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
+        let stem = entry_path
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .ok_or_else(|| NativeError {
+                message: format!("invalid entry path: {}", entry_path.display()),
+            })?
+            .to_string();
+
+        for f in &effective_features {
+            if !merged_features.contains(f) {
+                merged_features.push(f.clone());
+            }
+        }
+        for m in native_modules {
+            let dup = merged_native_modules
+                .iter()
+                .any(|x| x.package_name == m.package_name && x.crate_path == m.crate_path);
+            if !dup {
+                merged_native_modules.push(m);
+            }
+        }
+        let extra = native_build.rust_dependencies_toml.trim();
+        if !extra.is_empty() {
+            merged_extra_deps.push_str(extra);
+            merged_extra_deps.push('\n');
+        }
+        needs_tokio |= rust_code.contains("#[tokio::main]");
+        needs_ui |= rust_code.contains("tishlang_ui");
+        bins.push((stem, rust_code, native_build.generated_native_rs));
+    }
+
+    let merged_extra = merged_extra_deps.trim();
+    crate::build::build_many_via_cargo(
+        bins,
+        merged_native_modules,
+        &merged_features,
+        merged_extra,
+        needs_tokio,
+        needs_ui,
+        entries,
+        project_root,
+    )
+    .map_err(|e| NativeError { message: e })
+}
+
 enum Backend {
     Rust,
     Cranelift,

package/crates/tish_parser/src/lib.rs

@@ -252,4 +252,81 @@ 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
         }
@@ -270,10 +291,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected identifier")?;
+        let name = name_tok.literal.clone().ok_or("Expected identifier")?;
 
         // Optional type annotation: `: Type`
         let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
@@ -327,10 +345,7 @@ impl<'a> Parser<'a> {
                     start: name_tok.span.start,
                     end: name_tok.span.end,
                 };
-                let name = name_tok
-                    .literal
-                    .clone()
-                    .ok_or("Expected identifier")?;
+                let name = name_tok.literal.clone().ok_or("Expected identifier")?;
                 elements.push(Some(DestructElement::Rest(name, name_span)));
                 break;
             }
@@ -347,10 +362,7 @@ impl<'a> Parser<'a> {
                         start: name_tok.span.start,
                         end: name_tok.span.end,
                     };
-                    let name = name_tok
-                        .literal
-                        .clone()
-                        .ok_or("Expected identifier")?;
+                    let name = name_tok.literal.clone().ok_or("Expected identifier")?;
                     DestructElement::Ident(name, name_span)
                 }
                 _ => return Err("Expected identifier or pattern in destructuring".to_string()),
@@ -378,10 +390,7 @@ impl<'a> Parser<'a> {
                 start: key_tok.span.start,
                 end: key_tok.span.end,
             };
-            let key = key_tok
-                .literal
-                .clone()
-                .ok_or("Expected identifier")?;
+            let key = key_tok.literal.clone().ok_or("Expected identifier")?;
 
             let value = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                 self.advance();
@@ -397,10 +406,7 @@ impl<'a> Parser<'a> {
                             start: name_tok.span.start,
                             end: name_tok.span.end,
                         };
-                        let name = name_tok
-                            .literal
-                            .clone()
-                            .ok_or("Expected identifier")?;
+                        let name = name_tok.literal.clone().ok_or("Expected identifier")?;
                         DestructElement::Ident(name, name_span)
                     }
                     _ => return Err("Expected identifier or pattern after ':'".to_string()),
@@ -453,10 +459,7 @@ impl<'a> Parser<'a> {
             start: param_tok.span.start,
             end: param_tok.span.end,
         };
-        let param_name = param_tok
-            .literal
-            .clone()
-            .ok_or("Expected param name")?;
+        let param_name = param_tok.literal.clone().ok_or("Expected param name")?;
         let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
             self.advance();
             Some(self.parse_type_annotation()?)
@@ -528,11 +531,27 @@ impl<'a> Parser<'a> {
                 self.advance(); // {
                 let mut props = Vec::new();
                 while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
-                    let key = self
-                        .expect(TokenKind::Ident)?
-                        .literal
-                        .clone()
-                        .ok_or("Expected property name")?;
+                    // `for` is a keyword but a common method name (`Symbol.for`); allow it here.
+                    let key: Arc<str> = match self.peek_kind() {
+                        Some(TokenKind::Ident) => {
+                            let tok = self.expect(TokenKind::Ident)?;
+                            Arc::from(
+                                tok.literal
+                                    .as_deref()
+                                    .ok_or("Expected property name")?,
+                            )
+                        }
+                        Some(TokenKind::For) => {
+                            self.advance();
+                            Arc::from("for")
+                        }
+                        _ => {
+                            return Err(format!(
+                                "Expected Ident or `for` as object type property name, got {:?}",
+                                self.peek_kind()
+                            ));
+                        }
+                    };
                     self.expect(TokenKind::Colon)?;
                     let typ = self.parse_type_annotation()?;
                     props.push((key, typ));
@@ -580,10 +599,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected function name")?;
+        let name = name_tok.literal.clone().ok_or("Expected function name")?;
         self.expect(TokenKind::LParen)?;
         let mut params = Vec::with_capacity(4);
         let mut rest_param = None;
@@ -595,10 +611,7 @@ impl<'a> Parser<'a> {
                     start: rest_tok.span.start,
                     end: rest_tok.span.end,
                 };
-                let param_name = rest_tok
-                    .literal
-                    .clone()
-                    .ok_or("Expected rest param name")?;
+                let param_name = rest_tok.literal.clone().ok_or("Expected rest param name")?;
                 // Optional type annotation for rest param
                 let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                     self.advance();
@@ -681,10 +694,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected type alias name")?;
+        let name = name_tok.literal.clone().ok_or("Expected type alias name")?;
         self.expect(TokenKind::Assign)?;
         let ty = self.parse_type_annotation()?;
         Ok(Statement::TypeAlias {
@@ -726,10 +736,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected identifier")?;
+        let name = name_tok.literal.clone().ok_or("Expected identifier")?;
         let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
             self.advance();
             Some(self.parse_type_annotation()?)
@@ -759,10 +766,7 @@ impl<'a> Parser<'a> {
             start: name_tok.span.start,
             end: name_tok.span.end,
         };
-        let name = name_tok
-            .literal
-            .clone()
-            .ok_or("Expected function name")?;
+        let name = name_tok.literal.clone().ok_or("Expected function name")?;
         self.expect(TokenKind::LParen)?;
         let mut params = Vec::with_capacity(4);
         let mut rest_param = None;
@@ -774,10 +778,7 @@ impl<'a> Parser<'a> {
                     start: rest_tok.span.start,
                     end: rest_tok.span.end,
                 };
-                let param_name = rest_tok
-                    .literal
-                    .clone()
-                    .ok_or("Expected rest param name")?;
+                let param_name = rest_tok.literal.clone().ok_or("Expected rest param name")?;
                 let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                     self.advance();
                     Some(self.parse_type_annotation()?)
@@ -872,10 +873,7 @@ impl<'a> Parser<'a> {
                 start: for_name_tok.span.start,
                 end: for_name_tok.span.end,
             };
-            let name = for_name_tok
-                .literal
-                .clone()
-                .ok_or("Expected identifier")?;
+            let name = for_name_tok.literal.clone().ok_or("Expected identifier")?;
             if matches!(self.peek_kind(), Some(TokenKind::Of)) {
                 self.advance();
                 let iterable = self.parse_expr()?;
@@ -938,6 +936,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 {
@@ -1160,10 +1163,7 @@ impl<'a> Parser<'a> {
                 start: def_tok.span.start,
                 end: def_tok.span.end,
             };
-            let name = def_tok
-                .literal
-                .clone()
-                .ok_or("Expected identifier")?;
+            let name = def_tok.literal.clone().ok_or("Expected identifier")?;
             vec![ImportSpecifier::Default { name, name_span }]
         } else {
             return Err("Expected { }, * as name, or default import".to_string());
@@ -1245,7 +1245,9 @@ impl<'a> Parser<'a> {
             // Member assignment: obj.prop = val
             if let Expr::Member {
                 object,
-                prop: MemberProp::Name { name: prop_name, .. },
+                prop: MemberProp::Name {
+                    name: prop_name, ..
+                },
                 ..
             } = &left
             {
@@ -1483,11 +1485,8 @@ impl<'a> Parser<'a> {
                 TokenKind::Dot | TokenKind::OptionalChain => {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
-                    let prop_tok = self.expect(TokenKind::Ident)?;
-                    let prop = prop_tok
-                        .literal
-                        .clone()
-                        .ok_or("Expected property name")?;
+                    let prop_tok = self.expect_ident_or_type_member_name()?;
+                    let prop = prop_tok.literal.clone().ok_or("Expected property name")?;
                     let prop_span = Span {
                         start: prop_tok.span.start,
                         end: prop_tok.span.end,
@@ -1603,11 +1602,8 @@ impl<'a> Parser<'a> {
                 TokenKind::Dot | TokenKind::OptionalChain => {
                     let optional = kind == TokenKind::OptionalChain;
                     self.advance();
-                    let prop_tok = self.expect(TokenKind::Ident)?;
-                    let prop = prop_tok
-                        .literal
-                        .clone()
-                        .ok_or("Expected property name")?;
+                    let prop_tok = self.expect_ident_or_type_member_name()?;
+                    let prop = prop_tok.literal.clone().ok_or("Expected property name")?;
                     let prop_span = Span {
                         start: prop_tok.span.start,
                         end: prop_tok.span.end,
@@ -1997,7 +1993,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/crates/tish_pg/src/error.rs

@@ -1,5 +1,5 @@
-use std::fmt::Write as _;
 use std::error::Error as StdError;
+use std::fmt::Write as _;
 
 use deadpool::managed::PoolError;
 use thiserror::Error;