@tishlang/tish-lsp 2.12.0 → 2.35.0

package/crates/tish_parser/src/parser.rs

@@ -123,8 +123,17 @@ pub struct Parser<'a> {
     generic_specializations: Vec<Statement>,
     /// Names of specializations already generated (dedup).
     generic_done: HashSet<String>,
+    /// Current recursion depth of the expression/statement descent, bounded by [`MAX_PARSE_DEPTH`] so
+    /// pathologically nested untrusted source (`((((…`, `[[[[…`, `{{{{…`, `-!-!…`) returns a CATCHABLE
+    /// parse error instead of overflowing the native stack and aborting the whole process (#381).
+    depth: usize,
 }
 
+/// Maximum expression/statement nesting the parser will descend before returning a catchable error.
+/// Deep enough for any realistic hand-written or generated source; shallow enough that the descent
+/// stays well within the OS thread stack. Mirrors `MAX_JSON_DEPTH` in the JSON parser.
+const MAX_PARSE_DEPTH: usize = 1024;
+
 impl<'a> Parser<'a> {
     pub fn new(tokens: &'a [Token]) -> Self {
         Self {
@@ -134,9 +143,25 @@ impl<'a> Parser<'a> {
             generic_aliases: HashMap::new(),
             generic_specializations: Vec::new(),
             generic_done: HashSet::new(),
+            depth: 0,
         }
     }
 
+    /// Enter one level of recursive descent. Returns a catchable `Err` (never a panic/abort) once the
+    /// nesting exceeds [`MAX_PARSE_DEPTH`]. Pair every `Ok(())` return with a matching `self.depth -=
+    /// 1` on the way out (the `parse_unary`/`parse_statement` wrappers do this unconditionally). #381
+    fn enter_depth(&mut self) -> Result<(), String> {
+        self.depth += 1;
+        if self.depth > MAX_PARSE_DEPTH {
+            self.depth -= 1;
+            return Err(format!(
+                "parse error: nesting too deep (exceeded {} levels)",
+                MAX_PARSE_DEPTH
+            ));
+        }
+        Ok(())
+    }
+
     /// Close one generic-arg `>`: use a previously-split `>>` debt, consume a `>`, or split a
     /// `>>` (consuming it and owing one `>` to the parent). Returns false if there's no closer.
     fn try_close_angle(&mut self) -> bool {
@@ -259,7 +284,16 @@ impl<'a> Parser<'a> {
         Ok(Program { statements })
     }
 
+    /// Depth-guarded wrapper (#381): bounds block/statement nesting (`{{{{…`, `if(x){if(x){…`) so a
+    /// crafted deeply-nested program returns a catchable error instead of a stack-overflow abort.
     fn parse_statement(&mut self) -> Result<Statement, String> {
+        self.enter_depth()?;
+        let r = stacker::maybe_grow(64 * 1024, 512 * 1024, || self.parse_statement_inner());
+        self.depth -= 1;
+        r
+    }
+
+    fn parse_statement_inner(&mut self) -> Result<Statement, String> {
         let kind = self.peek_kind().ok_or("Unexpected EOF")?;
         let span_start = self.peek().map(|t| t.span.start).unwrap_or((0, 0));
 
@@ -1256,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()?)
@@ -1579,9 +1628,86 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// #305 — consume a `from "..."` clause (`from` is a soft keyword: an `Ident` whose spelling is
+    /// "from"), returning the module path string.
+    fn parse_from_clause(&mut self) -> Result<Arc<str>, String> {
+        let from_tok = self.expect(TokenKind::Ident)?;
+        if from_tok.literal.as_deref() != Some("from") {
+            return Err("Expected 'from' in re-export statement".to_string());
+        }
+        self.expect(TokenKind::String)?
+            .literal
+            .clone()
+            .ok_or_else(|| "Expected string path in re-export".to_string())
+    }
+
     fn parse_export(&mut self) -> Result<Statement, String> {
         let span_start = self.expect(TokenKind::Export)?.span.start;
-        let declaration = if matches!(self.peek_kind(), Some(TokenKind::Default)) {
+        let declaration = if matches!(self.peek_kind(), Some(TokenKind::LBrace)) {
+            // #305: re-export named — `export { foo, bar as inc } from "./m"`
+            self.advance(); // {
+            let mut specifiers = Vec::new();
+            while !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
+                let name_tok = self.expect(TokenKind::Ident)?;
+                let name_span = Span {
+                    start: name_tok.span.start,
+                    end: name_tok.span.end,
+                };
+                let name = name_tok
+                    .literal
+                    .clone()
+                    .ok_or("Expected identifier in export")?;
+                let (alias, alias_span) = if matches!(self.peek_kind(), Some(TokenKind::As)) {
+                    self.advance(); // as
+                    let alias_tok = self.expect(TokenKind::Ident)?;
+                    let asp = Span {
+                        start: alias_tok.span.start,
+                        end: alias_tok.span.end,
+                    };
+                    (
+                        Some(alias_tok.literal.clone().ok_or("Expected alias after 'as'")?),
+                        Some(asp),
+                    )
+                } else {
+                    (None, None)
+                };
+                specifiers.push(ImportSpecifier::Named {
+                    name,
+                    name_span,
+                    alias,
+                    alias_span,
+                });
+                if !matches!(self.peek_kind(), Some(TokenKind::RBrace)) {
+                    self.expect(TokenKind::Comma)?;
+                }
+            }
+            self.expect(TokenKind::RBrace)?;
+            // #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,
+                from,
+                span: self.span_end(span_start),
+            }
+        } else if matches!(self.peek_kind(), Some(TokenKind::Star)) {
+            // #305: re-export all — `export * from "./m"` (always requires `from`).
+            self.advance(); // *
+            let from = Some(self.parse_from_clause()?);
+            ExportDeclaration::ReExport {
+                specifiers: Vec::new(),
+                all: true,
+                from,
+                span: self.span_end(span_start),
+            }
+        } else if matches!(self.peek_kind(), Some(TokenKind::Default)) {
             self.advance();
             let expr = self.parse_expr()?;
             ExportDeclaration::Default(expr)
@@ -1617,6 +1743,73 @@ impl<'a> Parser<'a> {
         self.parse_assign()
     }
 
+    /// #304 — is `e` a side-effect-free l-value whose object/index sub-expressions can be safely
+    /// DUPLICATED by a compound/inc-dec desugar (no Call/New/assignment/inc-dec inside)? The desugar
+    /// reads and writes the same target, so duplicating a side-effecting sub-expression would run it
+    /// twice; those targets keep the existing parse error rather than mis-evaluate.
+    fn is_simple_lvalue(e: &Expr) -> bool {
+        match e {
+            Expr::Ident { .. } | Expr::Literal { .. } => true,
+            Expr::Member { object, prop, .. } => {
+                Self::is_simple_lvalue(object)
+                    && match prop {
+                        MemberProp::Name { .. } => true,
+                        MemberProp::Expr(pe) => Self::is_simple_lvalue(pe),
+                    }
+            }
+            Expr::Index { object, index, .. } => {
+                Self::is_simple_lvalue(object) && Self::is_simple_lvalue(index)
+            }
+            _ => false,
+        }
+    }
+
+    /// #304 — does `e` name a member (`obj.x`) or index (`arr[i]`) target the read-modify-write
+    /// desugar can handle (a simple l-value)?
+    fn is_desugarable_member_target(e: &Expr) -> bool {
+        Self::is_simple_lvalue(e)
+            && matches!(
+                e,
+                Expr::Member { prop: MemberProp::Name { .. }, .. } | Expr::Index { .. }
+            )
+    }
+
+    fn compound_op_to_binop(op: CompoundOp) -> BinOp {
+        match op {
+            CompoundOp::Add => BinOp::Add,
+            CompoundOp::Sub => BinOp::Sub,
+            CompoundOp::Mul => BinOp::Mul,
+            CompoundOp::Div => BinOp::Div,
+            CompoundOp::Mod => BinOp::Mod,
+        }
+    }
+
+    /// #304 — desugar a read-modify-write on a member/index target into the existing
+    /// `MemberAssign`/`IndexAssign` node (so every backend handles it for free). `make_value(read)`
+    /// builds the stored value from a clone of the target read (e.g. `read + 1`, `read || rhs`).
+    /// Caller must have checked [`Self::is_desugarable_member_target`].
+    fn desugar_member_rmw(left: &Expr, span: Span, make_value: impl FnOnce(Expr) -> Expr) -> Expr {
+        match left {
+            Expr::Member {
+                object,
+                prop: MemberProp::Name { name, .. },
+                ..
+            } => Expr::MemberAssign {
+                object: object.clone(),
+                prop: Arc::clone(name),
+                value: Box::new(make_value(left.clone())),
+                span,
+            },
+            Expr::Index { object, index, .. } => Expr::IndexAssign {
+                object: object.clone(),
+                index: index.clone(),
+                value: Box::new(make_value(left.clone())),
+                span,
+            },
+            _ => unreachable!("desugar_member_rmw on non-member/index target"),
+        }
+    }
+
     fn parse_assign(&mut self) -> Result<Expr, String> {
         let left = self.parse_conditional()?;
 
@@ -1686,18 +1879,29 @@ impl<'a> Parser<'a> {
         };
 
         if let Some(op) = compound_op {
-            if let Expr::Ident { name, span } = &left {
-                let name = Arc::clone(name);
-                let start = span.start;
+            let is_ident = matches!(&left, Expr::Ident { .. });
+            if is_ident || Self::is_desugarable_member_target(&left) {
+                let start = left.span().start;
                 self.advance(); // consume the compound operator
                 let value = self.parse_assign()?;
                 let end = value.span().end;
-                return Ok(Expr::CompoundAssign {
-                    name,
-                    op,
-                    value: Box::new(value),
-                    span: Span { start, end },
-                });
+                let span = Span { start, end };
+                if let Expr::Ident { name, .. } = &left {
+                    return Ok(Expr::CompoundAssign {
+                        name: Arc::clone(name),
+                        op,
+                        value: Box::new(value),
+                        span,
+                    });
+                }
+                // #304: `obj.x += e` / `arr[i] *= e` -> MemberAssign/IndexAssign(read <op> e).
+                let binop = Self::compound_op_to_binop(op);
+                return Ok(Self::desugar_member_rmw(&left, span, move |read| Expr::Binary {
+                    left: Box::new(read),
+                    op: binop,
+                    right: Box::new(value),
+                    span,
+                }));
             }
         }
 
@@ -1710,18 +1914,42 @@ impl<'a> Parser<'a> {
         };
 
         if let Some(op) = logical_op {
-            if let Expr::Ident { name, span } = &left {
-                let name = Arc::clone(name);
-                let start = span.start;
+            let is_ident = matches!(&left, Expr::Ident { .. });
+            if is_ident || Self::is_desugarable_member_target(&left) {
+                let start = left.span().start;
                 self.advance(); // consume the logical assign operator
                 let value = self.parse_assign()?;
                 let end = value.span().end;
-                return Ok(Expr::LogicalAssign {
-                    name,
-                    op,
-                    value: Box::new(value),
-                    span: Span { start, end },
-                });
+                let span = Span { start, end };
+                if let Expr::Ident { name, .. } = &left {
+                    return Ok(Expr::LogicalAssign {
+                        name: Arc::clone(name),
+                        op,
+                        value: Box::new(value),
+                        span,
+                    });
+                }
+                // #304: `obj.x ||= e` -> MemberAssign/IndexAssign(read || e) (short-circuit preserved,
+                // since `||`/`&&`/`??` evaluate the RHS lazily).
+                return Ok(Self::desugar_member_rmw(&left, span, move |read| match op {
+                    LogicalAssignOp::OrOr => Expr::Binary {
+                        left: Box::new(read),
+                        op: BinOp::Or,
+                        right: Box::new(value),
+                        span,
+                    },
+                    LogicalAssignOp::AndAnd => Expr::Binary {
+                        left: Box::new(read),
+                        op: BinOp::And,
+                        right: Box::new(value),
+                        span,
+                    },
+                    LogicalAssignOp::Nullish => Expr::NullishCoalesce {
+                        left: Box::new(read),
+                        right: Box::new(value),
+                        span,
+                    },
+                }));
             }
         }
 
@@ -1772,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);
@@ -1797,7 +2070,19 @@ impl<'a> Parser<'a> {
         Ok(left)
     }
 
+    /// Depth-guarded wrapper (#381): every expression operand and every nested `(…)`/`[…]`/`{…}`/
+    /// prefix-op re-enters `parse_unary`, so bounding it here bounds all expression nesting. The
+    /// `-= 1` runs on both the `Ok` and `Err` paths, keeping the counter balanced.
     fn parse_unary(&mut self) -> Result<Expr, String> {
+        self.enter_depth()?;
+        // Grow the stack on demand (each nesting level costs a whole precedence-chain of frames), so
+        // we reach the MAX_PARSE_DEPTH bound and return a catchable error rather than overflowing.
+        let r = stacker::maybe_grow(64 * 1024, 512 * 1024, || self.parse_unary_inner());
+        self.depth -= 1;
+        r
+    }
+
+    fn parse_unary_inner(&mut self) -> Result<Expr, String> {
         // Handle prefix ++/-- (consolidated)
         if let Some(is_inc) = match self.peek_kind() {
             Some(TokenKind::PlusPlus) => Some(true),
@@ -1819,6 +2104,24 @@ impl<'a> Parser<'a> {
                     Expr::PrefixDec { name, span }
                 });
             }
+            // #304: prefix `++obj.x` / `--arr[i]` on a member/index target. Desugars to a
+            // read-modify-write, which yields the NEW value — exactly prefix semantics.
+            if Self::is_desugarable_member_target(&operand) {
+                let span = Span {
+                    start: span_start,
+                    end: operand.span().end,
+                };
+                let binop = if is_inc { BinOp::Add } else { BinOp::Sub };
+                return Ok(Self::desugar_member_rmw(&operand, span, |read| Expr::Binary {
+                    left: Box::new(read),
+                    op: binop,
+                    right: Box::new(Expr::Literal {
+                        value: Literal::Number(1.0),
+                        span,
+                    }),
+                    span,
+                }));
+            }
             return Err(format!(
                 "Prefix {} requires an identifier",
                 if is_inc { "++" } else { "--" }
@@ -2049,13 +2352,13 @@ impl<'a> Parser<'a> {
                     };
                 }
                 TokenKind::PlusPlus | TokenKind::MinusMinus => {
+                    let is_inc = kind == TokenKind::PlusPlus;
                     if let Expr::Ident {
                         name,
                         span: ident_span,
                     } = &expr
                     {
                         let name = Arc::clone(name);
-                        let is_inc = kind == TokenKind::PlusPlus;
                         let tok = self.advance().ok_or("Unexpected EOF")?;
                         let span = Span {
                             start: ident_span.start,
@@ -2066,6 +2369,26 @@ impl<'a> Parser<'a> {
                         } else {
                             Expr::PostfixDec { name, span }
                         };
+                    } else if Self::is_desugarable_member_target(&expr) {
+                        // #304: postfix `obj.x++` / `arr[i]--` on a member/index target. Desugars to a
+                        // read-modify-write (statement-position semantics: yields the NEW value; the
+                        // old-value result in expression position is a documented follow-up).
+                        let start = expr.span().start;
+                        let tok = self.advance().ok_or("Unexpected EOF")?;
+                        let span = Span {
+                            start,
+                            end: tok.span.end,
+                        };
+                        let binop = if is_inc { BinOp::Add } else { BinOp::Sub };
+                        expr = Self::desugar_member_rmw(&expr, span, |read| Expr::Binary {
+                            left: Box::new(read),
+                            op: binop,
+                            right: Box::new(Expr::Literal {
+                                value: Literal::Number(1.0),
+                                span,
+                            }),
+                            span,
+                        });
                     } else {
                         break;
                     }
@@ -2102,6 +2425,33 @@ impl<'a> Parser<'a> {
                     span,
                 })
             }
+            TokenKind::Regex => {
+                // #299: `/pattern/flags` desugars to `new RegExp("pattern", "flags")`. Every backend
+                // already lowers `new RegExp(str, str)`, so no codegen change is needed. The lexer
+                // encodes the literal as `pattern\0flags`; the pattern is kept verbatim (e.g. `\d+`).
+                let lit = t.literal.clone().ok_or("Expected regex literal")?;
+                let (pat, flags) = match lit.split_once('\u{0}') {
+                    Some((p, f)) => (Arc::from(p), Arc::from(f)),
+                    None => (Arc::clone(&lit), Arc::from("")),
+                };
+                Ok(Expr::New {
+                    callee: Box::new(Expr::Ident {
+                        name: Arc::from("RegExp"),
+                        span,
+                    }),
+                    args: vec![
+                        CallArg::Expr(Expr::Literal {
+                            value: Literal::String(pat),
+                            span,
+                        }),
+                        CallArg::Expr(Expr::Literal {
+                            value: Literal::String(flags),
+                            span,
+                        }),
+                    ],
+                    span,
+                })
+            }
             TokenKind::True => Ok(Expr::Literal {
                 value: Literal::Bool(true),
                 span,
@@ -2114,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,
@@ -2142,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
@@ -2302,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;
 
@@ -2356,6 +2764,7 @@ impl<'a> Parser<'a> {
         let end = self.previous_span_end();
 
         Ok(Some(Expr::ArrowFunction {
+            async_,
             params,
             body,
             span: Span {
@@ -2365,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)) {