atmos/os_lib/js/

parser.rs

//! 再帰下降 + 優先順位クライミングの JS パーサ。
//!
//! 全トークンを `Vec<Token>` に集めてインデックスで走査するため、アロー関数判定の
//! ような任意先読みが容易。エラーは致命的にせずベストエフォートで継続する
//! （失敗箇所は `Expression::Undefined` / `Statement::Empty` にフォールバック）。
//! セミコロンは任意（改行ベースの ASI は簡易扱い）。

use alloc::rc::Rc;
use alloc::boxed::Box;
use alloc::string::String;
use alloc::vec::Vec;

use super::ast::*;
use super::lexer::{Lexer, Token};

/// 回復して解析を続けた構文エラー 1 件。
///
/// 【2026-07-28】本パーサは「エラーを致命的にせずベストエフォートで継続」する
/// 方針だが、従来は**回復したことを誰にも伝えていなかった**ため、壊れた
/// スクリプトが「正常に解析できた」のと区別できなかった（`expect_sym` は
/// `let _ = self.eat_sym(s);` と、期待した記号が無い事実を捨てていた）。
/// 実行はこれまでどおり継続しつつ、**何をどこで諦めたのかは必ず呼び出し側へ
/// 返す**ためにこの記録を持つ。
#[derive(Debug, Clone, PartialEq)]
pub struct ParseError {
    /// 何を期待して何が来たか。
    pub message: String,
    /// トークン列上の位置（`Parser` 内部のトークン索引）。
    pub token_index: usize,
}

/// 記録する構文エラーの上限。壊れきった入力で無制限にメモリを食わないため。
const MAX_RECORDED_ERRORS: usize = 64;

/// エラーメッセージ用にトークンを短く説明する。
fn describe_token(t: &Token) -> String {
    match t {
        Token::Keyword(k) => alloc::format!("keyword '{}'", k),
        Token::Ident(i) => alloc::format!("identifier '{}'", i),
        Token::Num(n) => alloc::format!("number {}", n),
        Token::BigIntLit(s) => alloc::format!("bigint {}", s),
        Token::Str(_) => String::from("string literal"),
        Token::Template(_) => String::from("template literal"),
        Token::Sym(s) => alloc::format!("'{}'", s),
        Token::Regex(_) => String::from("regex literal"),
        Token::LazyBody(..) => String::from("function body"),
        Token::Eof => String::from("end of input"),
    }
}

/// 固定長の塊を並べた追記専用の配列（索引で引ける）。
///
/// 【2026-10-19】YouTube の視聴ページの kevlar_base（10.8MB、約 320 万トークン）で、
/// `Vec<Token>` が倍々に伸びて 128MB の連続領域を要求し、ヒープ（512MB、使用 325MB）で
/// 確保に失敗していた。塊（`CHUNK` 個）ごとに確保すれば、大きな連続領域も、伸長時の
/// 旧・新の二重持ちも要らない。
pub struct ChunkedVec<T> {
    chunks: Vec<Vec<T>>,
    len: usize,
}

impl<T> ChunkedVec<T> {
    const SHIFT: usize = 14;
    const CHUNK: usize = 1 << Self::SHIFT;

    pub fn new() -> Self {
        ChunkedVec { chunks: Vec::new(), len: 0 }
    }

    pub fn push(&mut self, v: T) {
        let need_new = match self.chunks.last() {
            Some(c) => c.len() >= Self::CHUNK,
            None => true,
        };
        if need_new {
            self.chunks.push(Vec::with_capacity(Self::CHUNK));
        }
        if let Some(c) = self.chunks.last_mut() {
            c.push(v);
            self.len += 1;
        }
    }

    pub fn len(&self) -> usize {
        self.len
    }

    pub fn is_empty(&self) -> bool {
        self.len == 0
    }

    pub fn get(&self, i: usize) -> Option<&T> {
        self.chunks.get(i >> Self::SHIFT)?.get(i & (Self::CHUNK - 1))
    }

    /// 位置 `from` 以降を（位置, 要素）で順に返す。
    pub fn iter_from(&self, from: usize) -> impl Iterator<Item = (usize, &T)> {
        (from..self.len).filter_map(move |i| self.get(i).map(|t| (i, t)))
    }
}

impl<T> Default for ChunkedVec<T> {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Parser {
    toks: ChunkedVec<Token>,
    pos: usize,
    /// 遅延解析（`new_lazy`）用: 各トークンの開始位置（文字単位）とソース。通常は空。
    starts: ChunkedVec<u32>,
    chars: Vec<char>,
    lazy: bool,
    /// 回復して解析を続けた構文エラーの記録（上限 `MAX_RECORDED_ERRORS` 件）。
    errors: Vec<ParseError>,
    /// 上限で切り捨てた分も含めた実際の検出件数。
    error_count: usize,
    /// いま解析している箇所が strict モードか（関数本体の `FnBody::strict` に記録する）。
    strict: bool,
}

impl Parser {
    pub fn new(lexer: Lexer) -> Self {
        Self::build(lexer, false)
    }

    /// 関数本体を遅延解析するパーサ（大きな本体はソースだけ持ち、初回実行時に解析する）。
    /// 本体の中の構文エラーは、その関数を初めて実行するときに報告される。
    pub fn new_lazy(lexer: Lexer) -> Self {
        Self::build(lexer, true)
    }

    fn build(mut lexer: Lexer, lazy: bool) -> Self {
        let mut toks = ChunkedVec::new();
        let mut starts = ChunkedVec::new();
        // 遅延モード: 関数本体らしい `{`（制御構文でない `)` の直後、または `=>` の直後）の
        // 中身が大きければ、トークンを貯めずに `LazyBody` 1 個に畳む。
        // 【2026-10-19】YouTube の kevlar_base（10.8MB）は全体が 1 つの関数で、本体を読み
        // 飛ばすためだけに 320 万トークン（約 186MB）を作っていた。
        let mut parens: Vec<bool> = Vec::new(); // `(` ごとに「制御構文の括弧か」
        let mut last_close_ctrl = false; // 直前の `)` が制御構文の括弧を閉じたか
        let mut prev: Option<Token> = None;
        let mut prev2: Option<Token> = None;
        let mut heritage = false; // `extends` 以降、クラス本体の `{` までは畳まない
        loop {
            let t = lexer.next_token();
            let start = lexer.token_start() as u32;
            if lazy {
                starts.push(start);
            }
            let eof = t == Token::Eof;
            let mut fold = false;
            if lazy {
                match &t {
                    Token::Sym("(") => {
                        fn w(t: &Option<Token>) -> Option<&str> {
                            match t {
                                Some(Token::Keyword(k)) => Some(k),
                                Some(Token::Ident(i)) => Some(i.as_str()),
                                _ => None,
                            }
                        }
                        let ctrl = matches!(w(&prev), Some("if" | "while" | "for" | "switch" | "catch" | "with"))
                            || (w(&prev) == Some("await") && w(&prev2) == Some("for"));
                        parens.push(ctrl);
                    }
                    Token::Sym(")") => last_close_ctrl = parens.pop().unwrap_or(false),
                    Token::Keyword("extends") => heritage = true,
                    Token::Sym("{") => {
                        fold = !heritage
                            && match &prev {
                                Some(Token::Sym(")")) => !last_close_ctrl,
                                Some(Token::Sym("=>")) => true,
                                _ => false,
                            };
                        heritage = false;
                    }
                    _ => {}
                }
            }
            prev2 = prev.replace(t.clone());
            toks.push(t);
            if eof {
                break;
            }
            if fold {
                Self::fold_body(&mut lexer, &mut toks, &mut starts, start);
                // 畳んだ（または展開した）本体の後は閉じ `}` が直前のトークン。
                prev2 = None;
                prev = Some(Token::Sym("}"));
            }
        }
        // 字句解析の異常（閉じ忘れの文字列・コメント、値が化けた数値リテラル）も
        // 呼び出し側から見れば同じ「構文エラー」なので、ここで引き取る。
        let lex_error_count = lexer.error_count();
        let mut errors: Vec<ParseError> = lexer
            .take_errors()
            .into_iter()
            .map(|e| ParseError {
                message: e.message,
                token_index: 0,
            })
            .collect();
        errors.truncate(MAX_RECORDED_ERRORS);
        let chars = if lazy { lexer.into_chars() } else { Vec::new() };
        Self {
            toks,
            pos: 0,
            starts,
            chars,
            lazy,
            errors,
            error_count: lex_error_count,
            strict: false,
        }
    }

    /// `{`（位置 `open_start`）の直後から対応する `}` までを読み、中身が `LAZY_MIN_TOKENS` 以上
    /// なら `LazyBody` に畳み、少なければ普通に並べる。閉じ `}`（または Eof）まで積む。
    fn fold_body(lexer: &mut Lexer, toks: &mut ChunkedVec<Token>, starts: &mut ChunkedVec<u32>, open_start: u32) {
        let mut buf: Vec<(Token, u32)> = Vec::new();
        let mut counting = false;
        let mut use_strict = false;
        let mut depth = 1usize;
        loop {
            let t = lexer.next_token();
            let st = lexer.token_start() as u32;
            match &t {
                Token::Sym("{") => depth += 1,
                Token::Sym("}") => depth -= 1,
                _ => {}
            }
            let end = t == Token::Eof || depth == 0;
            if end {
                if counting && t != Token::Eof {
                    toks.push(Token::LazyBody(open_start + 1, st, use_strict));
                    starts.push(open_start + 1);
                } else {
                    // 小さい本体、または閉じられていない（Eof）: 貯めたトークンをそのまま並べる。
                    // Eof で畳めなかった場合、読み捨てた分は失われるが、閉じていない本体は
                    // どのみち構文エラー。
                    for (bt, bs) in buf.drain(..) {
                        toks.push(bt);
                        starts.push(bs);
                    }
                }
                toks.push(t);
                starts.push(st);
                return;
            }
            if !counting {
                buf.push((t, st));
                if buf.len() >= LAZY_MIN_TOKENS {
                    use_strict = matches!(buf.first(), Some((Token::Str(s), _)) if s == "use strict")
                        && matches!(buf.get(1), Some((Token::Sym(";" | "}"), _)) | Some((Token::Str(_), _)));
                    counting = true;
                    buf = Vec::new();
                }
            }
        }
    }

    /// `at` から始まる文の並びの先頭（指令プロローグ）に `"use strict"` があるか。
    fn has_use_strict_directive(&self, mut at: usize) -> bool {
        while let Some(Token::Str(s)) = self.toks.get(at) {
            if s == "use strict" {
                return true;
            }
            // 指令は文字列だけの式文。`;` か次の文字列で区切られる（`"a" + x` 等は指令ではない）。
            match self.toks.get(at + 1) {
                Some(Token::Sym(";")) => at += 2,
                Some(Token::Str(_)) => at += 1,
                _ => return false,
            }
        }
        false
    }

    /// 関数本体（`{ ... }`）。遅延モードで本体が大きければ、対応する `}` まで読み飛ばして
    /// 中身のソースだけ持つ。
    fn parse_fn_body(&mut self) -> Rc<FnBody> {
        if self.is_sym("{") {
            if let (Token::LazyBody(a, b, us), true) = (self.at(1).clone(), self.sym_at(2, "}")) {
                let strict = self.strict || us;
                let (a, b) = (a as usize, b as usize);
                if a <= b && b <= self.chars.len() {
                    let src: String = self.chars[a..b].iter().collect();
                    self.pos += 3;
                    return FnBody::lazy(src, strict);
                }
            }
        }
        let strict = self.strict || (self.is_sym("{") && self.has_use_strict_directive(self.pos + 1));
        if self.lazy && self.is_sym("{") {
            if let Some(close) = self.matching_brace(self.pos) {
                if close - self.pos > LAZY_MIN_TOKENS {
                    let a = self.starts.get(self.pos).map_or(0, |&s| s as usize + 1);
                    let b = self.starts.get(close).map_or(a, |&s| s as usize);
                    if a <= b && b <= self.chars.len() {
                        let src: String = self.chars[a..b].iter().collect();
                        self.pos = close + 1;
                        return FnBody::lazy(src, strict);
                    }
                }
            }
        }
        let outer = core::mem::replace(&mut self.strict, strict);
        let body = self.parse_brace_body();
        self.strict = outer;
        FnBody::parsed_with(body, strict)
    }

    /// `open` の `{` に対応する `}` のトークン位置（テンプレート・正規表現は 1 トークンなので
    /// 中の括弧は数えない）。
    fn matching_brace(&self, open: usize) -> Option<usize> {
        let mut depth = 0usize;
        for (i, t) in self.toks.iter_from(open) {
            match t {
                Token::Sym("{") => depth += 1,
                Token::Sym("}") => {
                    depth = depth.checked_sub(1)?;
                    if depth == 0 {
                        return Some(i);
                    }
                }
                Token::Eof => return None,
                _ => {}
            }
        }
        None
    }

    /// 記録済みの構文エラー（上限まで）。
    pub fn errors(&self) -> &[ParseError] {
        &self.errors
    }

    /// 検出した構文エラーの総数（記録上限で切り捨てた分も含む）。
    pub fn error_count(&self) -> usize {
        self.error_count
    }

    /// 記録済みの構文エラーを取り出す（呼び出し側へ渡してログ出力する用途）。
    pub fn take_errors(&mut self) -> Vec<ParseError> {
        core::mem::take(&mut self.errors)
    }

    fn record_error(&mut self, message: String) {
        self.error_count += 1;
        if self.errors.len() < MAX_RECORDED_ERRORS {
            // 【2026-09-05】トークン索引だけでは何が起きたか分からない。
            //
            // 実際に「`unexpected ':' in expression (token #34956)`」という
            // 報告から原因の構文を突き止められず、候補を 16 種類も
            // 試すはめになった（すべて外れ）。前後のトークンを添えれば
            // どの構文で落ちたかがその場で分かる。
            let msg = alloc::format!("{} 付近: {}", message, self.context_around(self.pos));
            self.errors.push(ParseError {
                message: msg,
                token_index: self.pos,
            });
        }
    }

    /// エラー位置の前後のトークンを短い文字列にする。
    ///
    /// 前 6 個・後 3 個。落ちた位置は `»«` で囲む。
    fn context_around(&self, at: usize) -> String {
        let start = at.saturating_sub(6);
        let end = (at + 4).min(self.toks.len());
        let mut out = String::new();
        for i in start..end {
            let Some(t) = self.toks.get(i) else {
                break;
            };
            if i == at {
                out.push_str("»");
                out.push_str(&describe_token(t));
                out.push_str("«");
            } else {
                out.push_str(&describe_token(t));
            }
            out.push(' ');
        }
        out
    }

    /// 別インスタンス（テンプレート補間式などの副パーサ）が検出したエラーを
    /// 自分の記録へ取り込む。位置は副パーサ内の索引なので、由来が分かるよう
    /// 印を付ける。
    fn absorb_errors(&mut self, mut sub: Parser) {
        let count = sub.error_count();
        if count == 0 {
            return;
        }
        for e in sub.take_errors() {
            self.record_error(alloc::format!("in template expression: {}", e.message));
        }
        // 記録上限を超えた分も総数には反映する。
        if count > MAX_RECORDED_ERRORS {
            self.error_count += count - MAX_RECORDED_ERRORS;
        }
    }

    // --- トークンカーソル ---
    fn cur(&self) -> &Token {
        self.toks.get(self.pos).unwrap_or(&Token::Eof)
    }
    fn at(&self, off: usize) -> &Token {
        self.toks.get(self.pos + off).unwrap_or(&Token::Eof)
    }
    fn bump(&mut self) -> Token {
        let t = self.cur().clone();
        if self.pos < self.toks.len() {
            self.pos += 1;
        }
        t
    }
    fn is_eof(&self) -> bool {
        matches!(self.cur(), Token::Eof)
    }
    fn is_sym(&self, s: &str) -> bool {
        matches!(self.cur(), Token::Sym(x) if *x == s)
    }
    fn sym_at(&self, off: usize, s: &str) -> bool {
        matches!(self.at(off), Token::Sym(x) if *x == s)
    }
    fn ident_at(&self, off: usize, s: &str) -> bool {
        matches!(self.at(off), Token::Ident(x) if x == s)
    }
    fn kw_at(&self, off: usize, k: &str) -> bool {
        matches!(self.at(off), Token::Keyword(x) if *x == k)
    }
    /// `off` の位置がオブジェクト/クラスのプロパティ名になり得るトークン
    /// （識別子/予約語/文字列/数値）かどうか（`get`/`set` アクセサ判定の先読み用）。
    fn is_property_key_token(&self, off: usize) -> bool {
        matches!(
            self.at(off),
            Token::Ident(_) | Token::Keyword(_) | Token::Str(_) | Token::Num(_)
        )
    }
    fn eat_sym(&mut self, s: &str) -> bool {
        if self.is_sym(s) {
            self.pos += 1;
            true
        } else {
            false
        }
    }
    /// 記号 `s` を消費する。無ければ**回復して継続しつつ構文エラーとして記録**する
    /// （従来は `let _ =` で「無かった」事実ごと捨てていた）。
    fn expect_sym(&mut self, s: &str) {
        if !self.eat_sym(s) {
            let found = describe_token(self.cur());
            self.record_error(alloc::format!("expected '{}' but found {}", s, found));
        }
    }
    fn is_kw(&self, k: &str) -> bool {
        matches!(self.cur(), Token::Keyword(x) if *x == k)
    }
    fn eat_kw(&mut self, k: &str) -> bool {
        if self.is_kw(k) {
            self.pos += 1;
            true
        } else {
            false
        }
    }
    fn ident_name(&mut self) -> Option<String> {
        match self.cur().clone() {
            Token::Ident(n) => {
                self.pos += 1;
                Some(n)
            }
            // プロパティ名としてキーワードも許可 (obj.return 等)。
            Token::Keyword(n) => {
                self.pos += 1;
                Some(String::from(n))
            }
            _ => None,
        }
    }

    // --- プログラム ---
    pub fn parse_program(&mut self) -> Program {
        if self.has_use_strict_directive(self.pos) {
            self.strict = true;
        }
        let mut body = Vec::new();
        while !self.is_eof() {
            let before = self.pos;
            if let Some(stmt) = self.parse_statement() {
                body.push(stmt);
            }
            // 前進保証（無限ループ防止）。ここへ来るのは「文として解釈できない
            // トークンを読み飛ばした」場合であり、明確な構文エラーなので記録する。
            if self.pos == before {
                let found = describe_token(self.cur());
                self.record_error(alloc::format!("unexpected {}", found));
                self.pos += 1;
            }
        }
        Program { body }
    }

    /// パースし、**AST と構文エラーの両方**を返す。
    ///
    /// AST は従来どおり常に返る（ベストエフォート動作を変えない）ので、
    /// 呼び出し側は「実行はするが、壊れている事実は知っている」状態にできる。
    pub fn parse_program_reporting(&mut self) -> (Program, Vec<ParseError>) {
        let program = self.parse_program();
        let errors = self.take_errors();
        (program, errors)
    }

    // --- 文 ---
    fn parse_statement(&mut self) -> Option<Statement> {
        // セミコロン単独は空文。
        if self.eat_sym(";") {
            return Some(Statement::Empty);
        }
        if self.is_sym("{") {
            return Some(self.parse_block());
        }

        // `using`/`await using` 宣言（Explicit Resource Management、ES2023→ES2026ベースライン）。
        // `using` は予約語ではなく文脈依存キーワードのため、`using IDENT =` の形のときだけ
        // 宣言として扱う（`using` という名前の普通の変数式文と衝突しないようにするため）。
        if self.ident_at(0, "using")
            && matches!(self.at(1), Token::Ident(_))
            && self.sym_at(2, "=")
        {
            return self.parse_using_declaration(false);
        }
        if self.is_kw("await")
            && self.ident_at(1, "using")
            && matches!(self.at(2), Token::Ident(_))
            && self.sym_at(3, "=")
        {
            self.bump(); // await
            return self.parse_using_declaration(true);
        }

        // ラベル付き文 `label: statement`（主にループの `break label`/`continue label`
        // ターゲット用）。識別子の直後が `:` の場合のみ（三項演算子の `:` は先頭識別子の
        // 直後に来ないため衝突しない）。
        if let Token::Ident(label) = self.cur().clone() {
            if self.sym_at(1, ":") {
                self.bump(); // label
                self.bump(); // ':'
                let inner = self.parse_statement().unwrap_or(Statement::Empty);
                return Some(Statement::Labeled(label, Box::new(inner)));
            }
        }

        match self.cur().clone() {
            Token::Keyword(kw) => match kw {
                "var" | "let" | "const" => self.parse_var_declaration(),
                "if" => self.parse_if(),
                "while" => self.parse_while(),
                "do" => self.parse_do_while(),
                "for" => self.parse_for(),
                "function" => self.parse_function_declaration(false),
                "async" if self.kw_at(1, "function") => {
                    self.bump(); // async
                    self.parse_function_declaration(true)
                }
                "return" => {
                    self.bump();
                    if self.is_sym(";") || self.is_sym("}") || self.is_eof() {
                        self.eat_sym(";");
                        Some(Statement::Return(None))
                    } else {
                        let e = self.parse_expression();
                        self.eat_sym(";");
                        Some(Statement::Return(Some(e)))
                    }
                }
                "break" => {
                    self.bump();
                    // `break label;` — ASI の改行検知はこの字句解析器に無いため、次が
                    // 識別子ならラベルとみなす（`break;\nfoo` のような稀なケースは
                    // 非対応の簡略実装）。
                    let label = if let Token::Ident(n) = self.cur().clone() {
                        self.bump();
                        Some(n)
                    } else {
                        None
                    };
                    self.eat_sym(";");
                    Some(Statement::Break(label))
                }
                "continue" => {
                    self.bump();
                    let label = if let Token::Ident(n) = self.cur().clone() {
                        self.bump();
                        Some(n)
                    } else {
                        None
                    };
                    self.eat_sym(";");
                    Some(Statement::Continue(label))
                }
                "throw" => {
                    self.bump();
                    let e = self.parse_expression();
                    self.eat_sym(";");
                    Some(Statement::Throw(e))
                }
                "try" => self.parse_try(),
                "switch" => self.parse_switch(),
                "import" => self.parse_import(),
                "export" => self.parse_export(),
                "class" => {
                    // クラス宣言: `let Name = class ...` 相当に脱糖。
                    let cls = self.parse_class();
                    let name = if let Expression::Class { name: Some(n), .. } = &cls {
                        n.clone()
                    } else {
                        String::new()
                    };
                    self.eat_sym(";");
                    Some(Statement::VarDeclaration {
                        kind: VarKind::Let,
                        decls: alloc::vec![(Pattern::Identifier(name), Some(cls))],
                    })
                }
                _ => self.parse_expression_statement(),
            },
            _ => self.parse_expression_statement(),
        }
    }

    fn parse_block(&mut self) -> Statement {
        // 組み立て時に畳んだ本体が関数以外の文脈（ASI で区切られた `f()\n{ … }` 等）に
        // 現れたら、その場で中身を解析する。
        if self.is_sym("{") {
            if let (Token::LazyBody(a, b, us), true) = (self.at(1).clone(), self.sym_at(2, "}")) {
                let (a, b) = (a as usize, b as usize);
                if a <= b && b <= self.chars.len() {
                    let src: String = self.chars[a..b].iter().collect();
                    self.pos += 3;
                    return Statement::Block(parse_function_body_source(&src, self.strict || us));
                }
            }
        }
        self.expect_sym("{");
        let mut body = Vec::new();
        while !self.is_sym("}") && !self.is_eof() {
            let before = self.pos;
            if let Some(s) = self.parse_statement() {
                body.push(s);
            }
            if self.pos == before {
                self.pos += 1;
            }
        }
        self.expect_sym("}");
        Statement::Block(body)
    }

    /// `{ ... }` の中身を Vec<Statement> として取り出す（関数本体用）。
    fn parse_brace_body(&mut self) -> Vec<Statement> {
        match self.parse_block() {
            Statement::Block(b) => b,
            _ => Vec::new(),
        }
    }

    fn parse_var_declaration(&mut self) -> Option<Statement> {
        let kind = match self.bump() {
            Token::Keyword(k) => match k {
                "let" => VarKind::Let,
                "const" => VarKind::Const,
                _ => VarKind::Var,
            },
            _ => VarKind::Var,
        };
        let mut decls = Vec::new();
        loop {
            if self.is_eof() || self.is_sym(";") {
                break;
            }
            let pat = self.parse_pattern();
            let init = if self.eat_sym("=") {
                Some(self.parse_assignment())
            } else {
                None
            };
            decls.push((pat, init));
            if !self.eat_sym(",") {
                break;
            }
        }
        self.eat_sym(";");
        Some(Statement::VarDeclaration { kind, decls })
    }

    /// `using x = expr, y = expr2;` / `await using x = expr;`。
    /// 仕様上バインディングは単純な識別子のみ（分割代入パターンは不可）。
    fn parse_using_declaration(&mut self, is_await: bool) -> Option<Statement> {
        self.bump(); // "using"
        let kind = if is_await {
            VarKind::AwaitUsing
        } else {
            VarKind::Using
        };
        let mut decls = Vec::new();
        while let Some(name) = self.ident_name() {
            let init = if self.eat_sym("=") {
                Some(self.parse_assignment())
            } else {
                None
            };
            decls.push((Pattern::Identifier(name), init));
            if !self.eat_sym(",") {
                break;
            }
        }
        self.eat_sym(";");
        Some(Statement::VarDeclaration { kind, decls })
    }

    fn parse_if(&mut self) -> Option<Statement> {
        self.bump(); // if
        self.expect_sym("(");
        let test = self.parse_expression();
        self.expect_sym(")");
        let consequent = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
        let alternate = if self.eat_kw("else") {
            Some(Box::new(self.parse_statement().unwrap_or(Statement::Empty)))
        } else {
            None
        };
        Some(Statement::If {
            test,
            consequent,
            alternate,
        })
    }

    fn parse_while(&mut self) -> Option<Statement> {
        self.bump();
        self.expect_sym("(");
        let test = self.parse_expression();
        self.expect_sym(")");
        let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
        Some(Statement::While { test, body })
    }

    fn parse_do_while(&mut self) -> Option<Statement> {
        self.bump(); // do
        let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
        self.eat_kw("while");
        self.expect_sym("(");
        let test = self.parse_expression();
        self.expect_sym(")");
        self.eat_sym(";");
        Some(Statement::DoWhile { body, test })
    }

    fn parse_for(&mut self) -> Option<Statement> {
        self.bump(); // for
        let is_await = self.eat_kw("await");
        self.expect_sym("(");

        // for-in / for-of を宣言形式で検出。
        if self.is_kw("var") || self.is_kw("let") || self.is_kw("const") {
            let decl_kind = match self.bump() {
                Token::Keyword(k) => match k {
                    "let" => VarKind::Let,
                    "const" => VarKind::Const,
                    _ => VarKind::Var,
                },
                _ => VarKind::Var,
            };
            let pat = self.parse_pattern();
            if self.eat_kw("of") || self.is_kw("in") {
                let of = !self.is_kw("in");
                if !of {
                    self.bump();
                } // consume `in`
                let object = self.parse_expression();
                self.expect_sym(")");
                let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
                return Some(Statement::ForIn {
                    decl_kind: Some(decl_kind),
                    pattern: pat,
                    object,
                    body,
                    of,
                    is_await,
                });
            }
            // C スタイル: 残りの宣言子を読む。
            let init_expr = if self.eat_sym("=") {
                Some(self.parse_assignment())
            } else {
                None
            };
            let mut decls = alloc::vec![(pat, init_expr)];
            while self.eat_sym(",") {
                let p = self.parse_pattern();
                let i = if self.eat_sym("=") {
                    Some(self.parse_assignment())
                } else {
                    None
                };
                decls.push((p, i));
            }
            self.eat_sym(";");
            let init = Some(Box::new(Statement::VarDeclaration {
                kind: decl_kind,
                decls,
            }));
            return self.finish_c_for(init);
        }

        // 非宣言形式の for-of/for-in: `for (x of arr)` / `for (x in obj)`（x は単純識別子）。
        // 一般の式パーサは `in` を二項演算子として消費してしまうため使えず、
        // `IDENT of|in` の形を先読みで検出してから専用に処理する。
        if let Token::Ident(name) = self.cur().clone() {
            if self.kw_at(1, "of") || self.kw_at(1, "in") {
                let of = self.kw_at(1, "of");
                self.bump(); // ident
                self.bump(); // of/in
                let object = self.parse_expression();
                self.expect_sym(")");
                let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
                return Some(Statement::ForIn {
                    decl_kind: None,
                    pattern: Pattern::Identifier(name),
                    object,
                    body,
                    of,
                    is_await,
                });
            }
        }

        // 非宣言形式の分割代入 for-of/for-in: `for ([a,b] of arr)` / `for ({a,b} of obj)`。
        // `[`/`{` は for(...) の頭では値コンテキストなのでパターンとして一意に解釈できるが、
        // `for ([a,b] = [1,2]; ...)` のような C 形式 for の可能性もあるため、
        // パターンを試しにパースしてみて `of`/`in` が続かなければ巻き戻す。
        if self.is_sym("[") || self.is_sym("{") {
            let save = self.pos;
            // 【2026-09-05】巻き戻すときは**記録したエラーも巻き戻す**。
            // ここは「for-of/for-in か？」を試すだけの投機的な解析で、
            // 外れたら位置を戻して C 形式として読み直す。ところが
            // 位置しか戻していなかったため、試行中に出たエラーが残り、
            // 実際には正しい構文まで構文エラーとして報告していた。
            let err_save = (self.errors.len(), self.error_count);
            let pat = self.parse_pattern();
            if self.eat_kw("of") || self.is_kw("in") {
                let of = !self.is_kw("in");
                if !of {
                    self.bump();
                } // consume `in`
                let object = self.parse_expression();
                self.expect_sym(")");
                let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
                return Some(Statement::ForIn {
                    decl_kind: None,
                    pattern: pat,
                    object,
                    body,
                    of,
                    is_await,
                });
            }
            self.pos = save;
            self.errors.truncate(err_save.0);
            // 件数も戻す（2026-09-26。記録だけ戻して件数を戻していなかったため、
            // エラーの無い jQuery 1.8.2 で「42 syntax error(s)」と警告が出ていた）。
            self.error_count = err_save.1;
        }

        // 非宣言形式のメンバー/添字式 for-of/for-in: `for (obj.prop of arr)` / `for (obj[k] of arr)`。
        // `parse_call_member(false)`（呼出しは許可しない — member/index チェーンのみ）を使えば
        // `in` を二項演算子として誤消費しない。結果が Member/Index で直後に of/in が続けば
        // 採用し、そうでなければ（単純識別子や他の式だった場合）巻き戻して通常の C 形式へ。
        if !self.is_kw("var") && !self.is_kw("let") && !self.is_kw("const") {
            let save = self.pos;
            // 同上。外れたら位置とエラーの両方を戻す。
            // `for(;;)` は最初の `;` でここが失敗し、巻き戻した後は
            // 正しく解析できるのに、残ったエラーのせいで
            // 「式の位置に `;`」と報告されていた（jQuery 1.8.2 が
            // `for(;;)` を使っており、本体が丸ごと構文エラー扱いになっていた）。
            let err_save = (self.errors.len(), self.error_count);
            let expr = self.parse_call_member(false);
            let is_target = matches!(expr, Expression::Member { .. } | Expression::Index { .. });
            if is_target && (self.eat_kw("of") || self.is_kw("in")) {
                let of = !self.is_kw("in");
                if !of {
                    self.bump();
                } // consume `in`
                let object = self.parse_expression();
                self.expect_sym(")");
                let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
                return Some(Statement::ForIn {
                    decl_kind: None,
                    pattern: Pattern::Expr(Box::new(expr)),
                    object,
                    body,
                    of,
                    is_await,
                });
            }
            self.pos = save;
            self.errors.truncate(err_save.0);
            // 件数も戻す（2026-09-26。記録だけ戻して件数を戻していなかったため、
            // エラーの無い jQuery 1.8.2 で「42 syntax error(s)」と警告が出ていた）。
            self.error_count = err_save.1;
        }

        // init 式（無しの場合あり）
        let init = if self.is_sym(";") {
            None
        } else {
            let e = self.parse_expression();
            Some(Box::new(Statement::Expression(e)))
        };
        self.eat_sym(";");
        self.finish_c_for(init)
    }

    fn finish_c_for(&mut self, init: Option<Box<Statement>>) -> Option<Statement> {
        // init の `;` は呼び出し側で消費済み。
        let test = if self.is_sym(";") {
            None
        } else {
            Some(self.parse_expression())
        };
        self.eat_sym(";");
        let update = if self.is_sym(")") {
            None
        } else {
            Some(self.parse_expression())
        };
        self.expect_sym(")");
        let body = Box::new(self.parse_statement().unwrap_or(Statement::Empty));
        Some(Statement::For {
            init,
            test,
            update,
            body,
        })
    }

    fn parse_function_declaration(&mut self, is_async: bool) -> Option<Statement> {
        self.bump(); // function
        let is_generator = self.eat_sym("*");
        let name = self.ident_name().unwrap_or_default();
        let params = self.parse_param_list();
        let body = self.parse_fn_body();
        Some(Statement::FunctionDeclaration {
            name,
            params: Rc::new(params),
            body,
            is_async,
            is_generator,
        })
    }

    fn parse_try(&mut self) -> Option<Statement> {
        self.bump(); // try
        let block = self.parse_brace_body();
        let mut catch_param = None;
        let mut catch_block = None;
        let mut finally_block = None;
        if self.eat_kw("catch") {
            if self.eat_sym("(") {
                catch_param = Some(self.parse_pattern());
                self.expect_sym(")");
            }
            catch_block = Some(self.parse_brace_body());
        }
        if self.eat_kw("finally") {
            finally_block = Some(self.parse_brace_body());
        }
        Some(Statement::Try {
            block,
            catch_param,
            catch_block,
            finally_block,
        })
    }

    /// 文字列指定子（module specifier）を読む。`from "mod"` の "mod" 部分など。
    fn parse_module_specifier(&mut self) -> String {
        match self.cur().clone() {
            Token::Str(s) => {
                self.bump();
                s
            }
            _ => String::new(),
        }
    }

    /// 文脈依存キーワード（`from`/`as`）を ident として消費する。一致したら true。
    fn eat_contextual(&mut self, word: &str) -> bool {
        if matches!(self.cur(), Token::Ident(x) if x == word) {
            self.pos += 1;
            true
        } else {
            false
        }
    }

    /// `{ a, b as c }` の中身を (元名, ローカル名) ペアの列として読む。
    fn parse_named_specifiers(&mut self) -> Vec<(String, String)> {
        let mut out = Vec::new();
        self.expect_sym("{");
        while !self.is_sym("}") && !self.is_eof() {
            let orig = self.ident_name().unwrap_or_default();
            let local = if self.eat_contextual("as") {
                self.ident_name().unwrap_or_default()
            } else {
                orig.clone()
            };
            out.push((orig, local));
            if !self.eat_sym(",") {
                break;
            }
        }
        self.expect_sym("}");
        out
    }

    /// `import` 宣言。
    /// 形態: `import "mod"` / `import def from "mod"` /
    /// `import * as ns from "mod"` / `import { a, b as c } from "mod"` /
    /// `import def, { a } from "mod"` / `import def, * as ns from "mod"`。
    fn parse_import(&mut self) -> Option<Statement> {
        self.bump(); // import
        let mut default = None;
        let mut namespace = None;
        let mut named = Vec::new();

        // 副作用のみ: import "mod";
        if let Token::Str(s) = self.cur().clone() {
            self.bump();
            self.eat_sym(";");
            return Some(Statement::Import {
                source: s,
                default: None,
                namespace: None,
                named: Vec::new(),
                side_effect_only: true,
            });
        }

        // default インポート（識別子）。
        if let Token::Ident(n) = self.cur().clone() {
            self.bump();
            default = Some(n);
            self.eat_sym(","); // default の後に名前空間/名前付きが続く場合
        }

        // 名前空間 `* as ns`。
        if self.eat_sym("*") {
            self.eat_contextual("as");
            namespace = self.ident_name();
        } else if self.is_sym("{") {
            // 名前付き `{ a, b as c }`。
            named = self.parse_named_specifiers();
        }

        self.eat_contextual("from");
        let source = self.parse_module_specifier();
        self.eat_sym(";");
        Some(Statement::Import {
            source,
            default,
            namespace,
            named,
            side_effect_only: false,
        })
    }

    /// `export` 宣言。
    /// 形態: `export default <expr>` / `export { a, b as c }` /
    /// `export { a } from "mod"` / `export * from "mod"` /
    /// `export var/let/const/function/class ...`。
    fn parse_export(&mut self) -> Option<Statement> {
        self.bump(); // export

        // export default <expr>;
        if self.eat_kw("default") {
            // default の後は関数/クラス宣言または式。
            let expr = if self.is_kw("function") {
                self.parse_function_expression(false)
            } else if self.is_kw("async") && self.kw_at(1, "function") {
                self.bump(); // async
                self.parse_function_expression(true)
            } else if self.is_kw("class") {
                self.parse_class()
            } else {
                self.parse_assignment()
            };
            self.eat_sym(";");
            return Some(Statement::ExportDefault(expr));
        }

        // export * from "mod";
        if self.eat_sym("*") {
            self.eat_contextual("from");
            let source = self.parse_module_specifier();
            self.eat_sym(";");
            return Some(Statement::ExportAll { source });
        }

        // export { a, b as c } [from "mod"];
        if self.is_sym("{") {
            // ここでの (orig, local) は (ローカル名, 公開名) に読み替える。
            let specs = self.parse_named_specifiers();
            let source = if self.eat_contextual("from") {
                Some(self.parse_module_specifier())
            } else {
                None
            };
            self.eat_sym(";");
            return Some(Statement::ExportNamed {
                specifiers: specs,
                source,
            });
        }

        // export var/let/const/function/class ...
        let names = self.export_decl_names();
        let declaration = self.parse_statement().unwrap_or(Statement::Empty);
        Some(Statement::ExportDecl {
            declaration: Box::new(declaration),
            names,
        })
    }

    /// `export` に続く宣言から公開すべき名前を先読みで収集する（カーソルは進めない）。
    fn export_decl_names(&self) -> Vec<String> {
        let mut names = Vec::new();
        match self.cur() {
            Token::Keyword(k) if *k == "function" => {
                // function [*] name
                let mut off = 1;
                if self.sym_at(off, "*") {
                    off += 1;
                }
                if let Token::Ident(n) = self.at(off) {
                    names.push(n.clone());
                }
            }
            Token::Keyword(k) if *k == "async" => {
                // async function [*] name
                let mut off = 2;
                if self.sym_at(off, "*") {
                    off += 1;
                }
                if let Token::Ident(n) = self.at(off) {
                    names.push(n.clone());
                }
            }
            Token::Keyword(k) if *k == "class" => {
                if let Token::Ident(n) = self.at(1) {
                    names.push(n.clone());
                }
            }
            Token::Keyword(k) if *k == "var" || *k == "let" || *k == "const" => {
                // 単純な識別子束縛のみ収集（分割代入は対象外）。
                let mut off = 1;
                while let Token::Ident(n) = self.at(off) {
                    names.push(n.clone());
                    // 次が `,` なら継続。`=` 等が来たら打ち切る。
                    if self.sym_at(off + 1, ",") {
                        off += 2;
                    } else {
                        break;
                    }
                }
            }
            _ => {}
        }
        names
    }

    fn parse_expression_statement(&mut self) -> Option<Statement> {
        let e = self.parse_expression();
        self.eat_sym(";");
        Some(Statement::Expression(e))
    }

    fn parse_switch(&mut self) -> Option<Statement> {
        self.eat_kw("switch");
        self.expect_sym("(");
        let discriminant = self.parse_expression();
        self.expect_sym(")");
        self.expect_sym("{");
        let mut cases = Vec::new();
        while !self.is_sym("}") && !self.is_eof() {
            let test = if self.eat_kw("case") {
                let t = self.parse_expression();
                self.expect_sym(":");
                Some(t)
            } else if self.eat_kw("default") {
                self.expect_sym(":");
                None
            } else {
                // 想定外トークンはスキップして無限ループを避ける。
                self.bump();
                continue;
            };
            // 次の case/default/} までを本体として収集。
            let mut body = Vec::new();
            while !self.is_kw("case")
                && !self.is_kw("default")
                && !self.is_sym("}")
                && !self.is_eof()
            {
                let before = self.pos;
                if let Some(s) = self.parse_statement() {
                    body.push(s);
                }
                if self.pos == before {
                    self.pos += 1;
                }
            }
            cases.push(crate::os_lib::js::ast::SwitchCase { test, body });
        }
        self.expect_sym("}");
        Some(Statement::Switch {
            discriminant,
            cases,
        })
    }

    fn parse_param_list(&mut self) -> Vec<Param> {
        let mut params = Vec::new();
        if self.eat_sym("(") {
            while !self.is_sym(")") && !self.is_eof() {
                let is_rest = self.eat_sym("...");
                let pattern = self.parse_pattern();
                let default = if self.eat_sym("=") {
                    Some(self.parse_assignment())
                } else {
                    None
                };
                params.push(Param {
                    pattern,
                    default,
                    is_rest,
                });
                if !self.eat_sym(",") {
                    break;
                }
            }
            self.expect_sym(")");
        }
        params
    }

    /// 束縛パターンをパース（識別子 / `{...}` / `[...]`）。
    fn parse_pattern(&mut self) -> Pattern {
        if self.is_sym("{") {
            return self.parse_object_pattern();
        }
        if self.is_sym("[") {
            return self.parse_array_pattern();
        }
        Pattern::Identifier(self.ident_name().unwrap_or_default())
    }

    fn parse_object_pattern(&mut self) -> Pattern {
        self.expect_sym("{");
        let mut props = Vec::new();
        while !self.is_sym("}") && !self.is_eof() {
            if self.eat_sym("...") {
                let name = self.ident_name().unwrap_or_default();
                props.push(ObjPatProp {
                    key: String::new(),
                    computed_key: None,
                    value: Pattern::Identifier(name),
                    default: None,
                    is_rest: true,
                });
                break; // rest は最後。
            }
            // 算出プロパティ名 `{[expr]: target}`。以前は一切非対応で、`[` に遭遇すると
            // どの分岐にも該当せず `_ => break` に落ち、以降のプロパティ（分割代入先の
            // 残り全部）が消え、パース位置もずれて後続の解析まで巻き込んで壊れる
            // バグだった（クラス/オブジェクトリテラルの async/generator 修飾子と同種）。
            let (key, computed_key) = if self.eat_sym("[") {
                let ce = self.parse_assignment();
                self.expect_sym("]");
                (String::new(), Some(ce))
            } else {
                let k = match self.cur().clone() {
                    Token::Ident(n) => {
                        self.bump();
                        n
                    }
                    Token::Keyword(n) => {
                        self.bump();
                        String::from(n)
                    }
                    Token::Str(s) => {
                        self.bump();
                        s
                    }
                    Token::Num(n) => {
                        self.bump();
                        super::value::fmt_number(n)
                    }
                    _ => break,
                };
                (k, None)
            };
            // `key: target` で別名/ネスト、無ければ key 自身を束縛（算出キーの場合は
            // 仕様上 `: target` が必須なので、無ければ空の識別子にフォールバックする）。
            let value = if self.eat_sym(":") {
                self.parse_pattern()
            } else {
                Pattern::Identifier(key.clone())
            };
            let default = if self.eat_sym("=") {
                Some(self.parse_assignment())
            } else {
                None
            };
            props.push(ObjPatProp {
                key,
                computed_key,
                value,
                default,
                is_rest: false,
            });
            if !self.eat_sym(",") {
                break;
            }
        }
        self.expect_sym("}");
        Pattern::Object(props)
    }

    fn parse_array_pattern(&mut self) -> Pattern {
        self.expect_sym("[");
        let mut elems = Vec::new();
        while !self.is_sym("]") && !self.is_eof() {
            if self.is_sym(",") {
                // 穴 [a, , b]
                elems.push(ArrPatElem {
                    pattern: None,
                    default: None,
                    is_rest: false,
                });
                self.bump();
                continue;
            }
            let is_rest = self.eat_sym("...");
            let pat = self.parse_pattern();
            let default = if !is_rest && self.eat_sym("=") {
                Some(self.parse_assignment())
            } else {
                None
            };
            elems.push(ArrPatElem {
                pattern: Some(pat),
                default,
                is_rest,
            });
            if is_rest {
                break;
            }
            if !self.eat_sym(",") {
                break;
            }
        }
        self.expect_sym("]");
        Pattern::Array(elems)
    }

    // --- 式 ---
    pub fn parse_expression(&mut self) -> Expression {
        let first = self.parse_assignment();
        if !self.is_sym(",") {
            return first;
        }
        // カンマ演算子: 以前は後続の式で単純に上書きしており、先行する式（の副作用）が
        // AST から丸ごと消えてしまう重大なバグだった（`(a(), b())` が `a()` を一切
        // 呼ばないなど）。`Sequence` へ全要素を保持し、実行時に順番に評価する。
        let mut items = alloc::vec![first];
        while self.eat_sym(",") {
            items.push(self.parse_assignment());
        }
        Expression::Sequence(items)
    }

    fn parse_assignment(&mut self) -> Expression {
        // yield / yield* （generator 内、assignment レベル）。
        if self.is_kw("yield") {
            self.bump();
            let delegate = self.eat_sym("*");
            // 引数なし yield（`yield;` / `yield)` 等）を許容。
            let argument = if self.is_sym(";")
                || self.is_sym(")")
                || self.is_sym("]")
                || self.is_sym("}")
                || self.is_sym(",")
                || self.is_eof()
            {
                None
            } else {
                Some(Box::new(self.parse_assignment()))
            };
            return Expression::Yield { argument, delegate };
        }
        // アロー関数の先読み。
        if let Some(arrow) = self.try_parse_arrow() {
            return arrow;
        }
        let left = self.parse_conditional();
        if let Token::Sym(op) = self.cur().clone() {
            if is_assign_op(op) {
                self.bump();
                let value = self.parse_assignment();
                return Expression::Assign {
                    op: String::from(op),
                    target: Box::new(left),
                    value: Box::new(value),
                };
            }
        }
        left
    }

    fn try_parse_arrow(&mut self) -> Option<Expression> {
        let start = self.pos;
        // `async` 接頭辞（async function は arrow ではないので除外）。
        let is_async = if self.is_kw("async") {
            if self.kw_at(1, "function") {
                return None;
            }
            self.bump();
            true
        } else {
            false
        };
        // x => ...
        if let Token::Ident(name) = self.cur().clone() {
            if self.sym_at(1, "=>") {
                self.bump(); // ident
                self.bump(); // =>
                let body = self.parse_arrow_body();
                return Some(Expression::Function {
                    name: None,
                    params: Rc::new(alloc::vec![Param {
                        pattern: Pattern::Identifier(name),
                        default: None,
                        is_rest: false
                    }]),
                    body,
                    is_arrow: true,
                    is_async,
                    is_generator: false,
                });
            }
        }
        // ( params ) => ...
        if self.is_sym("(") {
            if let Some(close) = self.matching_paren() {
                if matches!(self.toks.get(close + 1), Some(Token::Sym(s)) if *s == "=>") {
                    let params = self.parse_param_list();
                    self.expect_sym("=>");
                    let body = self.parse_arrow_body();
                    return Some(Expression::Function {
                        name: None,
                        params: Rc::new(params),
                        body,
                        is_arrow: true,
                        is_async,
                        is_generator: false,
                    });
                }
            }
        }
        // arrow ではなかった。consume した `async` を巻き戻す。
        self.pos = start;
        None
    }

    /// 現在位置の `(` に対応する `)` のインデックスを返す。
    fn matching_paren(&self) -> Option<usize> {
        let mut depth = 0i32;
        let mut i = self.pos;
        while let Some(t) = self.toks.get(i) {
            match t {
                Token::Sym(s) if *s == "(" => depth += 1,
                Token::Sym(s) if *s == ")" => {
                    depth -= 1;
                    if depth == 0 {
                        return Some(i);
                    }
                }
                Token::Eof => return None,
                _ => {}
            }
            i += 1;
        }
        None
    }

    fn parse_arrow_body(&mut self) -> Rc<FnBody> {
        if self.is_sym("{") {
            self.parse_fn_body()
        } else {
            let e = self.parse_assignment();
            FnBody::parsed_with(alloc::vec![Statement::Return(Some(e))], self.strict)
        }
    }

    fn parse_conditional(&mut self) -> Expression {
        let test = self.parse_binary(0);
        if self.eat_sym("?") {
            let consequent = self.parse_assignment();
            self.expect_sym(":");
            let alternate = self.parse_assignment();
            return Expression::Conditional {
                test: Box::new(test),
                consequent: Box::new(consequent),
                alternate: Box::new(alternate),
            };
        }
        test
    }

    fn parse_binary(&mut self, min_prec: u8) -> Expression {
        let mut left = self.parse_unary();
        while let Some(op) = self.current_binop_str() {
            let prec = match bin_prec(&op) {
                Some(p) => p,
                None => break,
            };
            if prec < min_prec {
                break;
            }
            self.bump(); // operator
            let next_min = if is_right_assoc(&op) { prec } else { prec + 1 };
            let right = self.parse_binary(next_min);
            left = if let Some(lop) = to_logical(&op) {
                Expression::Logical {
                    op: lop,
                    left: Box::new(left),
                    right: Box::new(right),
                }
            } else if let Some(bop) = to_binop(&op) {
                Expression::Binary {
                    op: bop,
                    left: Box::new(left),
                    right: Box::new(right),
                }
            } else {
                left
            };
        }
        left
    }

    /// 現在のトークンが二項演算子なら、その文字列を返す（`instanceof`/`in` 含む）。
    fn current_binop_str(&self) -> Option<String> {
        match self.cur() {
            Token::Sym(s) if bin_prec(s).is_some() => Some(String::from(*s)),
            Token::Keyword(k) if *k == "instanceof" || *k == "in" => Some(String::from(*k)),
            _ => None,
        }
    }

    fn parse_unary(&mut self) -> Expression {
        // 前置演算子
        if let Token::Sym(s) = self.cur().clone() {
            let uop = match s {
                "!" => Some(UnaryOp::Not),
                "-" => Some(UnaryOp::Neg),
                "+" => Some(UnaryOp::Pos),
                "~" => Some(UnaryOp::BitNot),
                _ => None,
            };
            if let Some(op) = uop {
                self.bump();
                let expr = self.parse_unary();
                return Expression::Unary {
                    op,
                    expr: Box::new(expr),
                };
            }
            if s == "++" || s == "--" {
                self.bump();
                let target = self.parse_unary();
                return Expression::Update {
                    op: String::from(s),
                    prefix: true,
                    target: Box::new(target),
                };
            }
        }
        if let Token::Keyword(k) = self.cur().clone() {
            let uop = match k {
                "typeof" => Some(UnaryOp::TypeOf),
                "void" => Some(UnaryOp::Void),
                "delete" => Some(UnaryOp::Delete),
                _ => None,
            };
            if let Some(op) = uop {
                self.bump();
                let expr = self.parse_unary();
                return Expression::Unary {
                    op,
                    expr: Box::new(expr),
                };
            }
            if k == "await" {
                self.bump();
                let expr = self.parse_unary();
                return Expression::Await(Box::new(expr));
            }
            if k == "new" {
                return self.parse_new();
            }
        }
        self.parse_postfix()
    }

    fn parse_new(&mut self) -> Expression {
        self.bump(); // new
        // `new.target`（MetaProperty）。ドット直後が識別子 `target` の場合のみ該当し、
        // それ以外（`new Foo` 等の通常のコンストラクタ呼び出し）とは衝突しない。
        if self.is_sym(".") && self.ident_at(1, "target") {
            self.bump(); // .
            self.bump(); // target
            return self.parse_call_member_tail(Expression::NewTarget, true);
        }
        // callee は呼出を含まないメンバ式。
        let callee = self.parse_call_member(false);
        let arguments = if self.is_sym("(") {
            self.parse_arguments()
        } else {
            Vec::new()
        };
        let new_expr = Expression::New {
            callee: Box::new(callee),
            arguments,
        };
        // `new A(7).get()` の後続メンバ/呼出チェーンを継続。
        self.parse_call_member_tail(new_expr, true)
    }

    fn parse_postfix(&mut self) -> Expression {
        let expr = self.parse_call_member(true);
        if let Token::Sym(s) = self.cur().clone() {
            if s == "++" || s == "--" {
                self.bump();
                return Expression::Update {
                    op: String::from(s),
                    prefix: false,
                    target: Box::new(expr),
                };
            }
        }
        expr
    }

    /// メンバ/添字/呼出のチェーン。`allow_call=false` で呼出を抑止（new 用）。
    fn parse_call_member(&mut self, allow_call: bool) -> Expression {
        let expr = self.parse_primary();
        self.parse_call_member_tail(expr, allow_call)
    }

    /// 既存の式に続くメンバ/添字/呼出チェーンを消費する。
    fn parse_call_member_tail(&mut self, mut expr: Expression, allow_call: bool) -> Expression {
        loop {
            if self.eat_sym(".") {
                let prop = self.ident_name().unwrap_or_default();
                expr = Expression::Member {
                    object: Box::new(expr),
                    property: prop,
                    optional: false,
                };
            } else if self.is_sym("?.") {
                self.bump();
                if self.is_sym("(") && allow_call {
                    let arguments = self.parse_arguments();
                    expr = Expression::Call {
                        callee: Box::new(expr),
                        arguments,
                        optional: true,
                    };
                } else if self.is_sym("[") {
                    self.bump();
                    let index = self.parse_expression();
                    self.expect_sym("]");
                    expr = Expression::Index {
                        object: Box::new(expr),
                        index: Box::new(index),
                        optional: true,
                    };
                } else {
                    let prop = self.ident_name().unwrap_or_default();
                    expr = Expression::Member {
                        object: Box::new(expr),
                        property: prop,
                        optional: true,
                    };
                }
            } else if self.eat_sym("[") {
                let index = self.parse_expression();
                self.expect_sym("]");
                expr = Expression::Index {
                    object: Box::new(expr),
                    index: Box::new(index),
                    optional: false,
                };
            } else if self.is_sym("(") && allow_call {
                let arguments = self.parse_arguments();
                expr = Expression::Call {
                    callee: Box::new(expr),
                    arguments,
                    optional: false,
                };
            } else if allow_call && matches!(self.cur(), Token::Template(_)) {
                // タグ付きテンプレート `` tag`...` ``。以前はこの分岐が無く、`Template`
                // トークンが式の直後に来ると（primary の再入り口が無いため）静かに
                // パースが打ち切られる/崩れるバグだった（本キャンペーンで見つけてきた
                // 「未知トークンでの黙示的パース破壊」系と同種）。
                let parts = match self.cur().clone() {
                    Token::Template(p) => p,
                    _ => unreachable!(),
                };
                self.bump();
                let mut quasis = Vec::new();
                let mut raw = Vec::new();
                let mut exprs = Vec::new();
                for part in parts {
                    match part {
                        super::lexer::TemplatePart::Quasi(s, r) => {
                            quasis.push(s);
                            raw.push(r);
                        }
                        super::lexer::TemplatePart::Expr(src) => {
                            let mut sub = Parser::new(Lexer::new(&src));
                            exprs.push(sub.parse_assignment());
                            // テンプレート補間式の中の構文エラーも親へ引き継ぐ
                            // （別インスタンスで解析するため、捨てると誰も気づけない）。
                            self.absorb_errors(sub);
                        }
                    }
                }
                expr = Expression::TaggedTemplate {
                    tag: Box::new(expr),
                    quasis,
                    raw,
                    exprs,
                };
            } else {
                break;
            }
        }
        expr
    }

    fn parse_arguments(&mut self) -> Vec<Expression> {
        let mut args = Vec::new();
        self.expect_sym("(");
        while !self.is_sym(")") && !self.is_eof() {
            if self.eat_sym("...") {
                args.push(Expression::Spread(Box::new(self.parse_assignment())));
            } else {
                args.push(self.parse_assignment());
            }
            if !self.eat_sym(",") {
                break;
            }
        }
        self.expect_sym(")");
        args
    }

    fn parse_primary(&mut self) -> Expression {
        match self.cur().clone() {
            Token::Num(n) => {
                self.bump();
                Expression::Number(n)
            }
            Token::BigIntLit(s) => {
                self.bump();
                Expression::BigIntLit(s)
            }
            Token::Str(s) => {
                self.bump();
                Expression::Str(s)
            }
            Token::Regex(rf) => {
                self.bump();
                let (p, f) = *rf;
                Expression::Regex(p, f)
            }
            Token::Template(parts) => {
                self.bump();
                let mut quasis = Vec::new();
                let mut exprs = Vec::new();
                for part in parts {
                    match part {
                        super::lexer::TemplatePart::Quasi(s, _raw) => quasis.push(s),
                        super::lexer::TemplatePart::Expr(src) => {
                            // 補間式は独立したサブパーサで構文解析する（外側の解析状態を
                            // 汚さない）。comma 演算子は非対応（assignment 式まで。関数
                            // 引数リストの各要素パースと同じ簡略方針）。
                            let mut sub = Parser::new(Lexer::new(&src));
                            exprs.push(sub.parse_assignment());
                            // テンプレート補間式の中の構文エラーも親へ引き継ぐ
                            // （別インスタンスで解析するため、捨てると誰も気づけない）。
                            self.absorb_errors(sub);
                        }
                    }
                }
                Expression::TemplateLiteral { quasis, exprs }
            }
            Token::Ident(name) => {
                self.bump();
                Expression::Identifier(name)
            }
            Token::Keyword(kw) => match kw {
                "true" => {
                    self.bump();
                    Expression::Bool(true)
                }
                "false" => {
                    self.bump();
                    Expression::Bool(false)
                }
                "null" => {
                    self.bump();
                    Expression::Null
                }
                "undefined" => {
                    self.bump();
                    Expression::Undefined
                }
                "this" => {
                    self.bump();
                    Expression::This
                }
                "super" => {
                    self.bump();
                    Expression::Super
                }
                "function" => self.parse_function_expression(false),
                "async" if self.kw_at(1, "function") => {
                    self.bump(); // async
                    self.parse_function_expression(true)
                }
                "class" => self.parse_class(),
                // `of` は予約語ではない（for-of の文脈でだけ意味を持つ）。式の位置では普通の識別子
                // （2026-09-26。OpenStreetMap 埋め込みの JS が `new Uint8Array(of)` を使っていた）。
                "of" => {
                    self.bump();
                    Expression::Identifier(String::from("of"))
                }
                other => {
                    // 式の位置に来てはいけない予約語。従来は黙って
                    // `undefined` に置き換えていたため、`if` が消えるような
                    // 壊れ方をしても呼び出し側は何も気づけなかった。
                    let msg = alloc::format!("unexpected keyword '{}' in expression", other);
                    self.record_error(msg);
                    self.bump();
                    Expression::Undefined
                }
            },
            Token::Sym(s) => match s {
                "(" => {
                    self.bump();
                    let e = self.parse_expression();
                    self.expect_sym(")");
                    e
                }
                "[" => self.parse_array_literal(),
                "{" => self.parse_object_literal(),
                other => {
                    // 式として解釈できない記号（余分な `)` や `,` など）。
                    let msg = alloc::format!("unexpected '{}' in expression", other);
                    self.record_error(msg);
                    self.bump();
                    Expression::Undefined
                }
            },
            Token::Eof | Token::LazyBody(..) => Expression::Undefined,
        }
    }

    fn parse_function_expression(&mut self, is_async: bool) -> Expression {
        self.bump(); // function
        let is_generator = self.eat_sym("*");
        let name = match self.cur().clone() {
            Token::Ident(n) => {
                self.bump();
                Some(n)
            }
            _ => None,
        };
        let params = self.parse_param_list();
        let body = self.parse_fn_body();
        Expression::Function {
            name,
            params: Rc::new(params),
            body,
            is_arrow: false,
            is_async,
            is_generator,
        }
    }

    /// クラス（本体は常に strict モード）。
    fn parse_class(&mut self) -> Expression {
        let outer = core::mem::replace(&mut self.strict, true);
        let e = self.parse_class_inner();
        self.strict = outer;
        e
    }

    fn parse_class_inner(&mut self) -> Expression {
        self.eat_kw("class");
        let name = match self.cur().clone() {
            Token::Ident(n) => {
                self.bump();
                Some(n)
            }
            _ => None,
        };
        let superclass = if self.eat_kw("extends") {
            Some(Box::new(self.parse_conditional()))
        } else {
            None
        };
        self.expect_sym("{");
        let mut members = Vec::new();
        while !self.is_sym("}") && !self.is_eof() {
            if self.eat_sym(";") {
                continue;
            }
            // static 修飾子。以前は「次が `(` でなければ修飾子」という緩い判定で、
            // `class C { static = 5; }`（"static" という名前のフィールド）まで
            // 修飾子と誤認識し、後続の `=` がどの分岐にも該当せず読み飛ばされて
            // パース結果が壊れるバグがあった（`async`/`*` 修飾子と同種）。次のトークンが
            // 実際にメソッド/フィールド名や `{`（static block）になり得る場合のみ
            // 修飾子として扱う。
            let is_static = if let Token::Ident(n) = self.cur().clone() {
                n == "static"
                    && (self.is_property_key_token(1)
                        || self.sym_at(1, "[")
                        || self.sym_at(1, "*")
                        || self.sym_at(1, "{"))
            } else {
                false
            };
            if is_static {
                self.bump();
            }
            // `static { ... }`（ES2022 静的初期化ブロック）。
            if is_static && self.is_sym("{") {
                let body = self.parse_fn_body();
                members.push(ClassMember {
                    key: String::new(),
                    computed_key: None,
                    kind: MethodKind::StaticBlock,
                    params: Rc::new(Vec::new()),
                    body,
                    is_static: true,
                    field_init: None,
                    is_async: false,
                    is_generator: false,
                });
                continue;
            }
            // `async`/`*`（generator）修飾子。以前はどちらも一切認識されておらず、
            // `async method(){}`/`*method(){}` を含むクラス定義があると `key` の
            // マッチが `_ => { self.bump(); continue; }` に落ちてメソッド自体が
            // 丸ごと消え、パース位置がずれて後続メンバの解析も壊れるバグだった。
            // `async` の次が「メソッド名になり得るトークン」（識別子/キーワード/文字列/
            // 数値/`[`算出キー/`*`generator）でなければ、`async` 自身がプロパティ名
            // （`class C { async = 1; }` のようなフィールド名）と判断し、修飾子として
            // 消費しない（このガードが無いと `async` という名前のフィールドが壊れる）。
            let async_modifier_ok =
                self.is_property_key_token(1) || self.sym_at(1, "[") || self.sym_at(1, "*");
            let is_async = self.is_kw("async") && async_modifier_ok;
            if is_async {
                self.bump();
            }
            let is_generator = self.eat_sym("*");
            // アクセサ修飾子（`get name() {...}` / `set name(v) {...}`）。次の2トークンが
            // 「プロパティ名になり得るトークン」+ `(` の場合のみアクセサとして扱う
            // （`get(){}`＝"get" という名前のメソッド、`get: 1`＝"get" という名前の
            // フィールドと衝突しないようにするため）。算出名 `get [expr](){}` も、
            // 次が `[` ならこの文法上アクセサ以外の解釈があり得ないため許可する
            // （以前はここが漏れており `get [Symbol.iterator](){}` のようなパターンが
            // getter として認識されず、"get" という名前の孤立フィールド＋無関係な
            // 算出名メソッドという壊れた2メンバに分解されてしまっていた）。
            let accessor_kind = if let Token::Ident(n) = self.cur().clone() {
                if (n == "get" || n == "set")
                    && (self.sym_at(1, "[")
                        || (self.is_property_key_token(1) && self.sym_at(2, "(")))
                {
                    self.bump();
                    Some(n == "get")
                } else {
                    None
                }
            } else {
                None
            };
            // メソッド名。`[expr]` は算出メソッド名（`[Symbol.iterator]` 等）。
            let mut computed_key = None;
            let key = match self.cur().clone() {
                Token::Ident(n) => {
                    self.bump();
                    n
                }
                Token::Keyword(n) => {
                    self.bump();
                    String::from(n)
                }
                Token::Str(s) => {
                    self.bump();
                    s
                }
                Token::Num(n) => {
                    self.bump();
                    super::value::fmt_number(n)
                }
                Token::Sym("[") => {
                    self.bump();
                    computed_key = Some(self.parse_assignment());
                    self.expect_sym("]");
                    String::new()
                }
                _ => {
                    self.bump();
                    continue;
                }
            };
            if self.is_sym("(") {
                // メソッド（constructor 含む）。
                let params = self.parse_param_list();
                let body = self.parse_fn_body();
                let kind = match accessor_kind {
                    Some(true) => MethodKind::Getter,
                    Some(false) => MethodKind::Setter,
                    None if computed_key.is_none() && key == "constructor" => {
                        MethodKind::Constructor
                    }
                    None => MethodKind::Method,
                };
                members.push(ClassMember {
                    key,
                    computed_key,
                    kind,
                    params: Rc::new(params),
                    body,
                    is_static,
                    field_init: None,
                    is_async,
                    is_generator,
                });
            } else {
                // フィールド宣言: `key = expr;` または `key;`（`#key` も同じ経路。
                // lexer が '#' を識別子の一部として読むため key にそのまま含まれる）。
                let init = if self.eat_sym("=") {
                    Some(self.parse_assignment())
                } else {
                    None
                };
                self.eat_sym(";");
                members.push(ClassMember {
                    key,
                    // 算出フィールド名（`[expr] = init;`）は非対応（稀なパターンのため、
                    // メソッドの算出名 `[Symbol.iterator](){}` のみ対応する簡略化）。
                    computed_key: None,
                    kind: MethodKind::Field,
                    params: Rc::new(Vec::new()),
                    body: FnBody::parsed_with(Vec::new(), true),
                    is_static,
                    field_init: init,
                    is_async: false,
                    is_generator: false,
                });
            }
        }
        self.expect_sym("}");
        Expression::Class {
            name,
            superclass,
            members,
        }
    }

    fn parse_array_literal(&mut self) -> Expression {
        self.expect_sym("[");
        let mut items = Vec::new();
        while !self.is_sym("]") && !self.is_eof() {
            if self.is_sym(",") {
                // 穴あき配列 [1,,3] は undefined 扱い。
                items.push(Expression::Undefined);
                self.bump();
                continue;
            }
            if self.eat_sym("...") {
                items.push(Expression::Spread(Box::new(self.parse_assignment())));
            } else {
                items.push(self.parse_assignment());
            }
            if !self.eat_sym(",") {
                break;
            }
        }
        self.expect_sym("]");
        Expression::Array(items)
    }

    fn parse_object_literal(&mut self) -> Expression {
        self.expect_sym("{");
        let mut props = Vec::new();
        while !self.is_sym("}") && !self.is_eof() {
            // オブジェクトスプレッド {...o}
            if self.eat_sym("...") {
                let value = self.parse_assignment();
                props.push(Property {
                    key: String::from(crate::os_lib::js::ast::OBJECT_SPREAD_KEY),
                    value,
                    computed: None,
                    accessor: None,
                });
                if !self.eat_sym(",") {
                    break;
                }
                continue;
            }
            // `async`/`*`（generator）修飾子（`{ async method(){} }`/`{ *gen(){} }`）。
            // クラスのメソッド修飾子と同じ理由で以前は一切認識されず、遭遇すると
            // キー解析が丸ごと失敗してオブジェクトリテラル全体のパースが壊れていた。
            // `{ async: 1 }`（"async" という名前の通常プロパティ）との曖昧さ回避のため、
            // 次がメソッド名になり得るトークンの場合のみ修飾子として扱う
            // （クラス側の同種ガードと同じロジック）。
            let async_modifier_ok =
                self.is_property_key_token(1) || self.sym_at(1, "[") || self.sym_at(1, "*");
            let is_async = self.is_kw("async") && async_modifier_ok;
            if is_async {
                self.bump();
            }
            let is_generator = self.eat_sym("*");
            // アクセサ修飾子（`{get name() {...}}` / `{set name(v) {...}}`）。クラスの
            // アクセサ判定と同じ2トークン先読み規則（`get`/`set` の次が「プロパティ名に
            // なり得るトークン」+ `(` の場合のみアクセサ扱い）。算出名
            // `{ get [expr](){} }` も、次が `[` ならアクセサ以外の解釈があり得ないため
            // 許可する（クラス側の同種修正と同じ理由）。
            let accessor_kind = if let Token::Ident(n) = self.cur().clone() {
                if (n == "get" || n == "set")
                    && (self.sym_at(1, "[")
                        || (self.is_property_key_token(1) && self.sym_at(2, "(")))
                {
                    self.bump();
                    Some(n == "get")
                } else {
                    None
                }
            } else {
                None
            };
            // 算出キー {[expr]: v}
            let mut computed = None;
            // キー: 識別子 / 文字列 / 数値 / [computed]
            let key = match self.cur().clone() {
                Token::Ident(n) => {
                    self.bump();
                    n
                }
                Token::Keyword(n) => {
                    self.bump();
                    String::from(n)
                }
                Token::Str(s) => {
                    self.bump();
                    s
                }
                Token::Num(n) => {
                    self.bump();
                    super::value::fmt_number(n)
                }
                Token::Sym("[") => {
                    self.bump();
                    computed = Some(self.parse_assignment());
                    self.expect_sym("]");
                    String::new()
                }
                _ => break,
            };
            let value = if self.eat_sym(":") {
                self.parse_assignment()
            } else if self.is_sym("(") {
                // メソッド短縮 key(){...}
                let params = self.parse_param_list();
                let body = self.parse_fn_body();
                Expression::Function {
                    name: Some(key.clone()),
                    params: Rc::new(params),
                    body,
                    is_arrow: false,
                    is_async,
                    is_generator,
                }
            } else {
                // 短縮プロパティ {x}
                Expression::Identifier(key.clone())
            };
            props.push(Property {
                key,
                value,
                computed,
                accessor: accessor_kind,
            });
            if !self.eat_sym(",") {
                break;
            }
        }
        self.expect_sym("}");
        Expression::Object(props)
    }
}

// --- 演算子テーブル ---

fn is_assign_op(op: &str) -> bool {
    matches!(
        op,
        "=" | "+="
            | "-="
            | "*="
            | "/="
            | "%="
            | "**="
            | "&="
            | "|="
            | "^="
            | "<<="
            | ">>="
            | ">>>="
            | "&&="
            | "||="
            | "??="
    )
}

fn bin_prec(op: &str) -> Option<u8> {
    Some(match op {
        "??" => 1,
        "||" => 2,
        "&&" => 3,
        "|" => 4,
        "^" => 5,
        "&" => 6,
        "==" | "!=" | "===" | "!==" => 7,
        "<" | ">" | "<=" | ">=" | "instanceof" | "in" => 8,
        "<<" | ">>" | ">>>" => 9,
        "+" | "-" => 10,
        "*" | "/" | "%" => 11,
        "**" => 12,
        _ => return None,
    })
}

fn is_right_assoc(op: &str) -> bool {
    op == "**"
}

fn to_logical(op: &str) -> Option<LogicalOp> {
    match op {
        "&&" => Some(LogicalOp::And),
        "||" => Some(LogicalOp::Or),
        "??" => Some(LogicalOp::Nullish),
        _ => None,
    }
}

fn to_binop(op: &str) -> Option<BinaryOp> {
    Some(match op {
        "+" => BinaryOp::Add,
        "-" => BinaryOp::Sub,
        "*" => BinaryOp::Mul,
        "/" => BinaryOp::Div,
        "%" => BinaryOp::Mod,
        "**" => BinaryOp::Pow,
        "==" => BinaryOp::Eq,
        "!=" => BinaryOp::NotEq,
        "===" => BinaryOp::StrictEq,
        "!==" => BinaryOp::StrictNotEq,
        "<" => BinaryOp::Lt,
        ">" => BinaryOp::Gt,
        "<=" => BinaryOp::LtEq,
        ">=" => BinaryOp::GtEq,
        "&" => BinaryOp::BitAnd,
        "|" => BinaryOp::BitOr,
        "^" => BinaryOp::BitXor,
        "<<" => BinaryOp::Shl,
        ">>" => BinaryOp::Shr,
        ">>>" => BinaryOp::UShr,
        "instanceof" => BinaryOp::InstanceOf,
        "in" => BinaryOp::In,
        _ => return None,
    })
}

/// これ未満のトークン数の関数本体は遅延させずにその場で解析する（小さい関数は保持コストの方が大きい）。
const LAZY_MIN_TOKENS: usize = 24;

/// 遅延した関数本体のソース（`{` と `}` の内側）を解析する。入れ子の関数もまた遅延する。
pub fn parse_function_body_source(src: &str, strict: bool) -> Vec<Statement> {
    let mut p = Parser::new_lazy(Lexer::new(src));
    p.strict = strict;
    let mut body = Vec::new();
    while !p.is_eof() {
        let before = p.pos;
        if let Some(s) = p.parse_statement() {
            body.push(s);
        }
        if p.pos == before {
            p.pos += 1;
        }
    }
    if p.error_count() > 0 {
        crate::warn!("[JS] {} syntax error(s) in lazily parsed function body", p.error_count());
    }
    body
}