@tishlang/tish-format 2.16.13 → 2.35.0

package/crates/tish_parser/src/parser.rs

@@ -1290,6 +1290,21 @@ impl<'a> Parser<'a> {
                     span: self.span_end(span_start),
                 });
             }
+            // `for (let k in obj)` — after a declared loop variable, `in` is for-in enumeration, not
+            // the binary `in` operator (#413). Iterates the object's own enumerable keys.
+            if matches!(self.peek_kind(), Some(TokenKind::In)) {
+                self.advance();
+                let object = self.parse_expr()?;
+                self.expect(TokenKind::RParen)?;
+                let body = Box::new(self.parse_block_or_statement()?);
+                return Ok(Statement::ForIn {
+                    name,
+                    name_span,
+                    object,
+                    body,
+                    span: self.span_end(span_start),
+                });
+            }
             let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
                 self.advance();
                 Some(self.parse_type_annotation()?)
@@ -1667,7 +1682,15 @@ impl<'a> Parser<'a> {
                 }
             }
             self.expect(TokenKind::RBrace)?;
-            let from = self.parse_from_clause()?;
+            // #415: the `from` clause is OPTIONAL. `export { a, b as c } from "./m"` re-exports;
+            // `export { a, b as c }` (no `from`) is a LOCAL named export of already-declared bindings.
+            let from = if matches!(self.peek_kind(), Some(TokenKind::Ident))
+                && self.peek().and_then(|t| t.literal.as_deref()) == Some("from")
+            {
+                Some(self.parse_from_clause()?)
+            } else {
+                None
+            };
             ExportDeclaration::ReExport {
                 specifiers,
                 all: false,
@@ -1675,9 +1698,9 @@ impl<'a> Parser<'a> {
                 span: self.span_end(span_start),
             }
         } else if matches!(self.peek_kind(), Some(TokenKind::Star)) {
-            // #305: re-export all — `export * from "./m"`
+            // #305: re-export all — `export * from "./m"` (always requires `from`).
             self.advance(); // *
-            let from = self.parse_from_clause()?;
+            let from = Some(self.parse_from_clause()?);
             ExportDeclaration::ReExport {
                 specifiers: Vec::new(),
                 all: true,
@@ -1977,9 +2000,54 @@ impl<'a> Parser<'a> {
     binary_single_op!(parse_bit_and, parse_shift, BitAnd, BinOp::BitAnd);
 
     binary_multi_op!(parse_shift, parse_equality, Shl => BinOp::Shl, Shr => BinOp::Shr, UShr => BinOp::UShr);
-    binary_multi_op!(parse_equality, parse_comparison,
-        StrictEq => BinOp::StrictEq, StrictNe => BinOp::StrictNe,
-        Eq => BinOp::Eq, Ne => BinOp::Ne);
+
+    // Loose equality `==` / `!=` is rejected at parse, uniformly across every backend (#244). Its
+    // coercion is a footgun, and leaving it accepted was a portability trap: interp/vm silently
+    // treated `==` as strict, the `--target js` backend emitted true JS loose `==` (so `1 == "1"`
+    // disagreed), and the native-rust backend refused to compile it. Only `===` / `!==` are accepted;
+    // `Eq` / `Ne` produce an actionable error pointing at the strict form. `StrictEq` / `StrictNe`
+    // parse exactly as the generic `binary_multi_op!` would.
+    fn parse_equality(&mut self) -> Result<Expr, String> {
+        let mut left = self.parse_comparison()?;
+        loop {
+            let op = match self.peek_kind() {
+                Some(TokenKind::StrictEq) => BinOp::StrictEq,
+                Some(TokenKind::StrictNe) => BinOp::StrictNe,
+                Some(TokenKind::Eq) => {
+                    let at = self
+                        .peek()
+                        .map(|t| format!("{:?}", t.span))
+                        .unwrap_or_else(|| "EOF".to_string());
+                    return Err(format!(
+                        "Loose equality '==' is not supported — use strict '===' (at {})",
+                        at
+                    ));
+                }
+                Some(TokenKind::Ne) => {
+                    let at = self
+                        .peek()
+                        .map(|t| format!("{:?}", t.span))
+                        .unwrap_or_else(|| "EOF".to_string());
+                    return Err(format!(
+                        "Loose inequality '!=' is not supported — use strict '!==' (at {})",
+                        at
+                    ));
+                }
+                _ => break,
+            };
+            self.advance();
+            let right = self.parse_comparison()?;
+            let start = expr_span(&left).start;
+            let end = expr_span(&right).end;
+            left = Expr::Binary {
+                left: Box::new(left),
+                op,
+                right: Box::new(right),
+                span: Span { start, end },
+            };
+        }
+        Ok(left)
+    }
     binary_multi_op!(parse_comparison, parse_term,
         Lt => BinOp::Lt, Le => BinOp::Le, Gt => BinOp::Gt, Ge => BinOp::Ge, In => BinOp::In);
     binary_multi_op!(parse_term, parse_factor, Plus => BinOp::Add, Minus => BinOp::Sub);
@@ -2396,17 +2464,71 @@ impl<'a> Parser<'a> {
                 value: Literal::Null,
                 span,
             }),
-            // `fn` / `type` as a value reference or single-param arrow head (issue #55).
-            // `fn`/`type` function-expressions don't exist and statement-leading decls are
-            // handled in parse_statement, so treating them as identifiers here is additive.
+            // `async` in expression position (#428): an async arrow — `async () => …` or
+            // `async x => …`. The body runs in async context (`await` allowed). Async function
+            // expressions / method shorthand need function-expression support, which tish lacks.
+            TokenKind::Async => {
+                if matches!(self.peek_kind(), Some(TokenKind::LParen)) {
+                    self.advance(); // consume `(`
+                    if let Some(arrow) = self.try_parse_arrow_function(&span, true)? {
+                        return Ok(arrow);
+                    }
+                    return Err("Expected an arrow function after `async (`".to_string());
+                }
+                if matches!(
+                    self.peek_kind(),
+                    Some(TokenKind::Ident | TokenKind::Fn | TokenKind::Type)
+                ) {
+                    let name_tok = self.advance().ok_or("Expected parameter name")?;
+                    let name = name_tok.literal.clone().ok_or("Expected parameter name")?;
+                    let name_span = Span {
+                        start: name_tok.span.start,
+                        end: name_tok.span.end,
+                    };
+                    self.expect(TokenKind::Arrow)?;
+                    let body = self.parse_arrow_body()?;
+                    let end = self.previous_span_end();
+                    return Ok(Expr::ArrowFunction {
+                        async_: true,
+                        params: vec![FunParam::Simple(TypedParam {
+                            name,
+                            name_span,
+                            type_ann: None,
+                            default: None,
+                        })],
+                        body,
+                        span: Span {
+                            start: span.start,
+                            end,
+                        },
+                    });
+                }
+                Err(
+                    "`async` in expression position must be followed by an arrow function (`async () => …`)"
+                        .to_string(),
+                )
+            }
+            // `fn` / `type` as a value reference or single-param arrow head (issue #55), OR a function
+            // EXPRESSION `function (…) {…}` / named `function f(…) {…}` (#464). statement-leading
+            // `function`/`type` decls are handled in parse_statement.
             TokenKind::Ident | TokenKind::Fn | TokenKind::Type => {
                 let name = t.literal.clone().ok_or("Expected ident")?;
+                let is_fn_kw = t.kind == TokenKind::Fn;
+                // Function expression: `function` (`Fn`) followed by `(` (anonymous) or an identifier
+                // (named) has no other valid meaning in value position. `t` is no longer read past
+                // here, so borrowing `self` for the peek is sound.
+                if is_fn_kw
+                    && matches!(self.peek_kind(), Some(TokenKind::LParen | TokenKind::Ident))
+                {
+                    return self.parse_function_expr_tail(&span, false);
+                }
                 // Check if this is a single-param arrow function: x => ...
                 if matches!(self.peek_kind(), Some(TokenKind::Arrow)) {
                     self.advance(); // consume =>
                     let body = self.parse_arrow_body()?;
                     let end = self.previous_span_end();
                     return Ok(Expr::ArrowFunction {
+                        async_: false,
                         params: vec![FunParam::Simple(TypedParam {
                             name: name.clone(),
                             name_span: span,
@@ -2424,7 +2546,7 @@ impl<'a> Parser<'a> {
             }
             TokenKind::LParen => {
                 // Check if this is an arrow function: (params) => ...
-                if let Some(arrow_fn) = self.try_parse_arrow_function(&span)? {
+                if let Some(arrow_fn) = self.try_parse_arrow_function(&span, false)? {
                     return Ok(arrow_fn);
                 }
                 // Otherwise it's a grouping expression
@@ -2584,7 +2706,11 @@ impl<'a> Parser<'a> {
 
     /// Try to parse an arrow function starting with '(' already consumed.
     /// Returns Some(Expr) if successful, None if it's not an arrow function.
-    fn try_parse_arrow_function(&mut self, start_span: &Span) -> Result<Option<Expr>, String> {
+    fn try_parse_arrow_function(
+        &mut self,
+        start_span: &Span,
+        async_: bool,
+    ) -> Result<Option<Expr>, String> {
         // Save position for backtracking
         let saved_pos = self.pos;
 
@@ -2638,6 +2764,7 @@ impl<'a> Parser<'a> {
         let end = self.previous_span_end();
 
         Ok(Some(Expr::ArrowFunction {
+            async_,
             params,
             body,
             span: Span {
@@ -2647,6 +2774,48 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    /// Parse a `function` EXPRESSION after its `function` token has been consumed (#464):
+    /// `[name] (params) [: RetType] { body }`. Lowers to an `ArrowFunction` with a block body so every
+    /// backend reuses the existing arrow path. An optional name is parsed for source fidelity but not
+    /// bound in scope, so a named function expression cannot yet self-reference by that name (a
+    /// documented follow-up). `this`/`arguments` follow arrow semantics — fine for the common callback
+    /// / IIFE / assigned-callback uses.
+    fn parse_function_expr_tail(
+        &mut self,
+        start_span: &Span,
+        async_: bool,
+    ) -> Result<Expr, String> {
+        // Optional name (named function expression).
+        if matches!(self.peek_kind(), Some(TokenKind::Ident)) {
+            self.advance();
+        }
+        self.expect(TokenKind::LParen)?;
+        let mut params = Vec::new();
+        while !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+            params.push(self.parse_fun_param()?);
+            if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                self.expect(TokenKind::Comma)?;
+            }
+        }
+        self.expect(TokenKind::RParen)?;
+        // Optional return-type annotation (`: T`) — parsed and discarded (ArrowFunction carries none).
+        if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+            self.advance();
+            self.parse_type_annotation()?;
+        }
+        let block = self.parse_block()?;
+        let end = self.previous_span_end();
+        Ok(Expr::ArrowFunction {
+            async_,
+            params,
+            body: ArrowBody::Block(Box::new(block)),
+            span: Span {
+                start: start_span.start,
+                end,
+            },
+        })
+    }
+
     /// Parse the body of an arrow function (either expression or block)
     fn parse_arrow_body(&mut self) -> Result<ArrowBody, String> {
         if matches!(self.peek_kind(), Some(TokenKind::LBrace)) {

package/crates/tish_resolve/src/lib.rs

@@ -177,6 +177,13 @@ fn collect_stmt(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             consider(source, lsp_line, lsp_char, name_span, name.clone(), best);
             collect_expr(iterable, source, lsp_line, lsp_char, best);
@@ -939,7 +946,12 @@ fn member_chain_collect_stmt(
             }
             member_chain_collect_stmt(body, source, lsp_line, lsp_char, best);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             member_chain_collect_expr(iterable, source, lsp_line, lsp_char, best);
             member_chain_collect_stmt(body, source, lsp_line, lsp_char, best);
         }
@@ -1414,6 +1426,13 @@ fn walk_stmt_resolve(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             if *name_span == tgt_span && name.as_ref() == target.name.as_ref() {
                 return Some(*name_span);
@@ -2028,6 +2047,13 @@ fn check_unresolved_stmt(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             check_unresolved_expr(iterable, scopes, out);
             scopes.push();
@@ -2556,6 +2582,13 @@ fn enumerate_stmt(stmt: &Statement, exported: bool, out: &mut Vec<BindingSite>)
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            object: iterable,
+            body,
+            ..
         } => {
             out.push(BindingSite {
                 name: name.clone(),
@@ -2731,7 +2764,12 @@ fn jsx_tags_stmt(s: &Statement, out: &mut std::collections::HashSet<Arc<str>>) {
             }
             jsx_tags_stmt(body, out);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             jsx_tags_expr(iterable, out);
             jsx_tags_stmt(body, out);
         }
@@ -3057,6 +3095,13 @@ fn collect_block_locals(
             body,
             span,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            name_span,
+            body,
+            span,
+            ..
         } => {
             if pos::span_contains_lsp_position(source, span, lsp_line, lsp_char)
                 && pos::span_contains_lsp_position(
@@ -3428,6 +3473,12 @@ fn walk_stmt_completion(
             iterable,
             body,
             ..
+        }
+        | Statement::ForIn {
+            name,
+            object: iterable,
+            body,
+            ..
         } => {
             walk_expr_completion(iterable, source, lsp_line, lsp_char, stack, best);
             let body_sp = body.as_ref().span();
@@ -3900,7 +3951,12 @@ fn tref_stmt(stmt: &Statement, out: &mut Vec<TypeOcc>) {
             }
             tref_stmt(body, out);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             tref_expr(iterable, out);
             tref_stmt(body, out);
         }
@@ -4061,7 +4117,12 @@ fn refs_stmt(
             }
             refs_stmt(body, program, source, name, def_span, out);
         }
-        Statement::ForOf { iterable, body, .. } => {
+        Statement::ForOf { iterable, body, .. }
+        | Statement::ForIn {
+            object: iterable,
+            body,
+            ..
+        } => {
             refs_expr(iterable, program, source, name, def_span, out);
             refs_stmt(body, program, source, name, def_span, out);
         }
@@ -4657,7 +4718,7 @@ mod tests {
 
     #[test]
     fn mutual_recursion_not_unresolved_or_unused() {
-        let src = "fn even(n) { if (n == 0) { return true } return odd(n - 1) }\nfn odd(n) { if (n == 0) { return false } return even(n - 1) }\neven(10)\n";
+        let src = "fn even(n) { if (n === 0) { return true } return odd(n - 1) }\nfn odd(n) { if (n === 0) { return false } return even(n - 1) }\neven(10)\n";
         let program = parse(src).expect("parse");
         assert!(
             collect_unresolved_identifiers(&program).is_empty(),

package/crates/tish_runtime/Cargo.toml

@@ -52,7 +52,9 @@ http-hyper = [
     "tokio/rt",
     "tokio/io-util",
 ]
-fs = []
+# `fs/promises` returns settled promises, so fs pulls in the promise machinery.
+# `mkdtemp` needs a random suffix (predictable/timestamp names are a temp-dir security smell).
+fs = ["promise", "dep:rand"]
 process = []
 # Interactive terminal I/O (issue #101): raw mode, key/resize events, size, alt screen.
 tty = ["dep:crossterm"]
@@ -81,6 +83,8 @@ reqwest = { version = "0.13.2", default-features = false, features = ["rustls",
 futures = { version = "0.3.32", optional = true }
 bytes = { version = "1", optional = true }
 tiny_http = { version = "0.12.0", optional = true }
+# fs feature only: random suffix for `mkdtemp`.
+rand = { version = "0.10.1", optional = true }
 socket2 = { version = "0.5", features = ["all"], optional = true }
 libc = { version = "0.2", optional = true }
 arc-swap = { version = "1", optional = true }