@tishlang/tish-lsp 2.12.0 → 2.35.0

package/crates/tish_opt/src/lib.rs

@@ -118,6 +118,19 @@ fn optimize_statement(stmt: &Statement) -> Statement {
             body: Box::new(optimize_statement(body)),
             span: *span,
         },
+        Statement::ForIn {
+            name,
+            name_span,
+            object,
+            body,
+            span,
+        } => Statement::ForIn {
+            name: Arc::clone(name),
+            name_span: *name_span,
+            object: optimize_expr(object),
+            body: Box::new(optimize_statement(body)),
+            span: *span,
+        },
         Statement::Return { value, span } => Statement::Return {
             value: value.as_ref().map(optimize_expr),
             span: *span,
@@ -500,12 +513,18 @@ fn optimize_expr(expr: &Expr) -> Expr {
             value: Box::new(optimize_expr(value)),
             span: *span,
         },
-        Expr::ArrowFunction { params, body, span } => {
+        Expr::ArrowFunction {
+            async_,
+            params,
+            body,
+            span,
+        } => {
             let opt_body = match body {
                 ArrowBody::Expr(e) => ArrowBody::Expr(Box::new(optimize_expr(e))),
                 ArrowBody::Block(s) => ArrowBody::Block(Box::new(optimize_statement(s))),
             };
             Expr::ArrowFunction {
+                async_: *async_,
                 params: params.clone(),
                 body: opt_body,
                 span: *span,

package/crates/tish_parser/Cargo.toml

@@ -9,3 +9,7 @@ repository = { workspace = true }
 [dependencies]
 tishlang_lexer = { path = "../tish_lexer", version = ">=0.1" }
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+# #381: grow the stack on demand during the recursive descent so deeply-nested source can't overflow
+# the fixed OS thread stack before the MAX_PARSE_DEPTH bound converts it into a catchable error.
+# (No-op shim on wasm32, matching tish_eval / tish_vm.)
+stacker = "0.1"

package/crates/tish_parser/src/lib.rs

@@ -33,6 +33,74 @@ mod tests {
     use super::*;
     use tishlang_ast::{CallArg, Expr, ObjectProp, Statement};
 
+    /// #381: pathologically nested source must return a catchable `Err`, NOT overflow the native
+    /// stack and abort the process. Exercises expression nesting (`((((…`), array nesting (`[[[[…`),
+    /// and prefix-op nesting (`-!-!…`) — all funnel through the depth-guarded `parse_unary`.
+    #[test]
+    fn deeply_nested_source_errors_instead_of_aborting() {
+        let n = 50_000;
+        for (open, close) in [("(", ")"), ("[", "]")] {
+            let src = format!("let x = {}1{}", open.repeat(n), close.repeat(n));
+            let r = parse(&src);
+            assert!(r.is_err(), "{n}× nested {open} should be a catchable Err, not an abort");
+            assert!(
+                r.unwrap_err().contains("nesting too deep"),
+                "expected a depth-limit error"
+            );
+        }
+        let prefix = format!("let x = {}1", "-".repeat(n));
+        assert!(parse(&prefix).is_err(), "deep prefix-op chain should error, not abort");
+    }
+
+    /// The depth guard must not reject ordinary, modestly-nested code.
+    #[test]
+    fn normal_nesting_still_parses() {
+        assert!(parse("let x = ((((1 + 2))))").is_ok());
+        assert!(parse("let y = [[1, 2], [3, [4, [5]]]]").is_ok());
+        assert!(parse("fn f() { if (a) { if (b) { return 1 } } }").is_ok());
+    }
+
+    /// #244: loose equality `==` / `!=` is rejected uniformly at parse (across every backend), with an
+    /// actionable message pointing at the strict form. `===` / `!==` still parse.
+    #[test]
+    fn loose_equality_is_rejected_at_parse() {
+        let eq = parse("let b = 1 == 1").unwrap_err();
+        assert!(eq.contains("'=='") && eq.contains("'==='"), "got: {eq}");
+        let ne = parse("let b = 1 != 2").unwrap_err();
+        assert!(ne.contains("'!='") && ne.contains("'!=='"), "got: {ne}");
+        // Rejected wherever an expression is parsed, not just at top level.
+        assert!(parse("fn f(x) { if (x == 0) { return 1 } return 0 }").is_err());
+        assert!(parse("let y = a != null && a.b").is_err());
+        // Strict forms are unaffected.
+        assert!(parse("let b = 1 === 1").is_ok());
+        assert!(parse("let b = 1 !== 2").is_ok());
+        assert!(parse("let y = a !== null && a.b").is_ok());
+    }
+
+    /// #428: `async` in expression position parses as an async arrow (paren and single-param forms);
+    /// non-async arrows keep `async_: false`.
+    #[test]
+    fn async_arrow_expressions_parse() {
+        use tishlang_ast::Expr;
+        let arrow_async = |src: &str| -> bool {
+            let p = parse(src).expect("parse");
+            let Some(Statement::VarDecl { init: Some(e), .. }) = p.statements.first() else {
+                panic!("expected `let x = <arrow>`");
+            };
+            match e {
+                Expr::ArrowFunction { async_, .. } => *async_,
+                other => panic!("expected ArrowFunction, got {other:?}"),
+            }
+        };
+        assert!(arrow_async("let f = async () => 1"), "async paren arrow");
+        assert!(arrow_async("let g = async x => x + 1"), "async single-param arrow");
+        assert!(arrow_async("let h = async (a, b) => a + b"), "async multi-param arrow");
+        assert!(!arrow_async("let f = () => 1"), "plain arrow is not async");
+        assert!(!arrow_async("let g = x => x"), "plain single-param arrow is not async");
+        // `async` not followed by an arrow in expr position is an error, not a silent identifier.
+        assert!(parse("let x = async 5").is_err());
+    }
+
     #[test]
     fn test_async_fn_parse() {
         let program = parse("async fn foo() { }").expect("parse async fn");