atmos/os_lib/js/

ast.rs

//! JavaScript の抽象構文木（実用コア相当）。
//!
//! Phase 1 のスコープ: 関数/クロージャ・制御構文・全演算子・オブジェクト/配列・
//! メンバ/添字/呼出/new・三項・論理・代入・try/catch/throw。
//! 分割代入・デフォルト引数・class などのモダン構文は Phase 4 で拡張する。

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

#[derive(Debug, Clone, PartialEq)]
pub enum BinaryOp {
    Add,
    Sub,
    Mul,
    Div,
    Mod,
    Pow,
    Eq,
    NotEq,
    StrictEq,
    StrictNotEq,
    Lt,
    Gt,
    LtEq,
    GtEq,
    BitAnd,
    BitOr,
    BitXor,
    Shl,
    Shr,
    UShr,
    InstanceOf,
    In,
}

#[derive(Debug, Clone, PartialEq)]
pub enum LogicalOp {
    And,     // &&
    Or,      // ||
    Nullish, // ??
}

#[derive(Debug, Clone, PartialEq)]
pub enum UnaryOp {
    Neg,    // -x
    Pos,    // +x
    Not,    // !x
    BitNot, // ~x
    TypeOf, // typeof x
    Void,   // void x
    Delete, // delete x
}

/// オブジェクトリテラルのプロパティ。
#[derive(Debug, Clone, PartialEq)]
pub struct Property {
    pub key: String,
    pub value: Expression,
    /// 算出キー `{[expr]: v}` の場合のキー式。None なら `key` を使う。
    pub computed: Option<Expression>,
    /// `{get x(){...}}`/`{set x(v){...}}` アクセサの場合 `Some(true)`/`Some(false)`。
    /// 通常のプロパティ（値/メソッド短縮/短縮プロパティ）は `None`。
    pub accessor: Option<bool>,
}

/// オブジェクトスプレッド `{...o}` を表す Property.key の番兵（通常キーと衝突しない制御文字）。
pub const OBJECT_SPREAD_KEY: &str = "\u{0}spread";

#[derive(Debug, Clone, PartialEq)]
pub enum Expression {
    Number(f64),
    /// BigInt リテラル（数値部分の文字列。0x/0o/0b 接頭辞を含み得る）。
    BigIntLit(String),
    Str(String),
    Bool(bool),
    Null,
    Undefined,
    Identifier(String),
    This,
    TemplateLiteral {
        // quasis.len() == exprs.len() + 1
        quasis: Vec<String>,
        exprs: Vec<Expression>,
    },
    /// タグ付きテンプレート `` tag`...${e}...` ``（ES2015）。`quasis`/`raw` は
    /// `TemplateLiteral` と同様 exprs より1つ多い。`tag(strings, ...values)` 呼出しで
    /// `strings` は `quasis` の配列に `.raw`（`raw` の配列）を added property として持つ。
    TaggedTemplate {
        tag: Box<Expression>,
        quasis: Vec<String>,
        raw: Vec<String>,
        exprs: Vec<Expression>,
    },
    Array(Vec<Expression>),
    Object(Vec<Property>),
    /// 関数式・アロー関数。本体と引数は `Rc` で共有する（【2026-10-17】従来は評価のたびに
    /// 本体の構文木を丸ごと複製しており、YouTube の base.js（全体が 1 つの即時関数）で
    /// 約 100MB の複製が起きていた）。
    Function {
        name: Option<String>,
        params: Rc<Vec<Param>>,
        body: Rc<FnBody>,
        is_arrow: bool,
        is_async: bool,
        is_generator: bool,
    },
    /// `await expr`。
    Await(Box<Expression>),
    /// `yield expr` / `yield* expr`。
    Yield {
        argument: Option<Box<Expression>>,
        delegate: bool,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expression>,
    },
    Update {
        op: String, // "++" / "--"
        prefix: bool,
        target: Box<Expression>,
    },
    Binary {
        op: BinaryOp,
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Logical {
        op: LogicalOp,
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Assign {
        op: String, // "=", "+=", "-=", ...
        target: Box<Expression>,
        value: Box<Expression>,
    },
    Conditional {
        test: Box<Expression>,
        consequent: Box<Expression>,
        alternate: Box<Expression>,
    },
    Member {
        object: Box<Expression>,
        property: String,
        optional: bool, // a?.b
    },
    Index {
        object: Box<Expression>,
        index: Box<Expression>,
        optional: bool, // a?.[b]
    },
    Call {
        callee: Box<Expression>,
        arguments: Vec<Expression>,
        optional: bool, // a?.()
    },
    New {
        callee: Box<Expression>,
        arguments: Vec<Expression>,
    },
    /// スプレッド要素 `...expr`（配列リテラル/呼出引数/オブジェクト内で展開される）。
    Spread(Box<Expression>),
    /// `class` 式/宣言。
    Class {
        name: Option<String>,
        superclass: Option<Box<Expression>>,
        members: Vec<ClassMember>,
    },
    /// `super`（`super(...)` / `super.x`）。
    Super,
    /// カンマ演算子 `a, b, c`。全要素を順に評価し、最後の値を返す
    /// （途中の要素の副作用も実行する。`for(i=0,j=10; ...)` 等で使われる）。
    Sequence(Vec<Expression>),
    /// `new.target`（MetaProperty。`new` 経由の呼び出しではコンストラクタ関数自身、
    /// 通常呼び出しでは `undefined`）。
    NewTarget,
    /// 正規表現リテラル `/pattern/flags`。
    Regex(String, String),
}

/// クラスメンバの種別。
#[derive(Debug, Clone, PartialEq)]
pub enum MethodKind {
    Method,
    Constructor,
    /// フィールド宣言（`x = expr;` または `x;`、`#x = expr;` を含む）。
    /// params/body は使わず、初期化式は ClassMember::field_init に持つ。
    Field,
    /// `get name() {...}`（アクセサ getter）。
    Getter,
    /// `set name(v) {...}`（アクセサ setter）。
    Setter,
    /// `static { ... }`（ES2022 静的初期化ブロック）。`body` に文の列を持つ
    /// （`key`/`params`/`field_init` は使わない）。
    StaticBlock,
}

/// クラスのメソッド/静的メソッド/フィールド宣言。
#[derive(Debug, Clone, PartialEq)]
pub struct ClassMember {
    pub key: String,
    /// 算出メソッド名 `[expr](){}`（`[Symbol.iterator]` 等）。Some の場合、実際のキーは
    /// クラス定義時にこれを評価して得る（`key` フィールドは無視される）。
    pub computed_key: Option<Expression>,
    pub kind: MethodKind,
    pub params: Rc<Vec<Param>>,
    pub body: Rc<FnBody>,
    pub is_static: bool,
    /// kind == Field のときのみ Some（初期化式。省略時は None → undefined 初期化）。
    pub field_init: Option<Expression>,
    /// `async method(){}`（kind == Method のときのみ意味を持つ）。
    pub is_async: bool,
    /// `*method(){}`/`async *method(){}`（kind == Method のときのみ意味を持つ）。
    pub is_generator: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub enum VarKind {
    Var,
    Let,
    Const,
    /// `using x = expr;`（Explicit Resource Management）。囲むブロック実行終了時に
    /// `x[Symbol.dispose]()` を宣言の逆順で呼ぶ。
    Using,
    /// `await using x = expr;`。`x[Symbol.asyncDispose]()` の戻り値を await する。
    AwaitUsing,
}

/// 束縛パターン（分割代入・引数）。
#[derive(Debug, Clone, PartialEq)]
pub enum Pattern {
    Identifier(String),
    /// `{ a, b: c, d = 1, ...rest }`
    Object(Vec<ObjPatProp>),
    /// `[ a, , b = 1, ...rest ]`
    Array(Vec<ArrPatElem>),
    /// メンバー/添字式への代入ターゲット（`for (obj.prop of arr)` / `for (obj[k] of arr)` 用）。
    /// 分割代入の宣言では使わず、非宣言形式 for-of/for-in の代入先としてのみ生成される。
    Expr(Box<Expression>),
}

/// オブジェクトパターンの 1 プロパティ。
#[derive(Debug, Clone, PartialEq)]
pub struct ObjPatProp {
    /// 取り出すソースキー（`is_rest` の場合は未使用。`computed_key` が Some の場合も
    /// 未使用で、実際のキーは束縛時に `computed_key` を評価して得る）。
    pub key: String,
    /// 算出プロパティ名 `{[expr]: target}`。Some の場合、`key` フィールドは無視される。
    pub computed_key: Option<Expression>,
    /// 束縛先パターン（`{a}` なら Identifier("a")、`{a: {b}}` ならネスト）。
    pub value: Pattern,
    pub default: Option<Expression>,
    pub is_rest: bool,
}

/// 配列パターンの 1 要素。
#[derive(Debug, Clone, PartialEq)]
pub struct ArrPatElem {
    /// None は穴 `[a, , b]`。
    pub pattern: Option<Pattern>,
    pub default: Option<Expression>,
    pub is_rest: bool,
}

/// 関数パラメータ（パターン＋デフォルト＋レスト）。
#[derive(Debug, Clone, PartialEq)]
pub struct Param {
    pub pattern: Pattern,
    pub default: Option<Expression>,
    pub is_rest: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub enum Statement {
    Expression(Expression),
    VarDeclaration {
        kind: VarKind,
        // 1 文で複数宣言可能: `let a = 1, b = 2;`。分割代入のため左辺は Pattern。
        decls: Vec<(Pattern, Option<Expression>)>,
    },
    Block(Vec<Statement>),
    If {
        test: Expression,
        consequent: Box<Statement>,
        alternate: Option<Box<Statement>>,
    },
    While {
        test: Expression,
        body: Box<Statement>,
    },
    DoWhile {
        body: Box<Statement>,
        test: Expression,
    },
    For {
        init: Option<Box<Statement>>,
        test: Option<Expression>,
        update: Option<Expression>,
        body: Box<Statement>,
    },
    ForIn {
        decl_kind: Option<VarKind>,
        pattern: Pattern,
        object: Expression,
        body: Box<Statement>,
        of: bool, // true: for-of, false: for-in
        /// `for await (x of iterable)`。`Symbol.asyncIterator` があればそれを駆動し、
        /// 無ければ同期イテラブルの各要素を await するフォールバック（`of` の時のみ意味を持つ）。
        is_await: bool,
    },
    FunctionDeclaration {
        name: String,
        params: Rc<Vec<Param>>,
        body: Rc<FnBody>,
        is_async: bool,
        is_generator: bool,
    },
    Return(Option<Expression>),
    /// `break;` / `break label;`。
    Break(Option<String>),
    /// `continue;` / `continue label;`。
    Continue(Option<String>),
    /// `label: statement`（ラベル付き文。主にループの `break label`/`continue label` の
    /// ターゲットとして使う）。
    Labeled(String, Box<Statement>),
    Throw(Expression),
    Switch {
        discriminant: Expression,
        cases: Vec<SwitchCase>,
    },
    Try {
        block: Vec<Statement>,
        /// `catch (e)`/`catch ({message})` 等。分割代入パターンにも対応（ES2015）。
        catch_param: Option<Pattern>,
        catch_block: Option<Vec<Statement>>,
        finally_block: Option<Vec<Statement>>,
    },
    /// `import ... from "spec"` 宣言。
    /// 例: `import def, { a, b as c }, * as ns from "mod"`。
    Import {
        /// モジュール指定子（指定子文字列）。
        source: String,
        /// default インポートの束縛名（`import def from ...`）。
        default: Option<String>,
        /// 名前空間インポートの束縛名（`import * as ns from ...`）。
        namespace: Option<String>,
        /// 名前付きインポート: (元の export 名, ローカル束縛名)。
        named: Vec<(String, String)>,
        /// 副作用のみ `import "mod"`（束縛なし）。
        side_effect_only: bool,
    },
    /// `export { a, b as c }` / `export { x } from "mod"`（再エクスポート）。
    ExportNamed {
        /// (ローカル名 or 元名, 公開する export 名)。
        specifiers: Vec<(String, String)>,
        /// 再エクスポート元の指定子（`export { x } from "mod"`）。None なら自モジュール。
        source: Option<String>,
    },
    /// `export default <expr>`。
    ExportDefault(Expression),
    /// `export var/let/const/function/class ...`（宣言を実行しつつ名前を export）。
    /// 内側の宣言文と、そこから公開する名前のリストを保持する。
    ExportDecl {
        declaration: Box<Statement>,
        names: Vec<String>,
    },
    /// `export * from "mod"`（全名前の再エクスポート）。
    ExportAll {
        source: String,
    },
    Empty,
}

/// switch の 1 ケース。`test` が None なら default。
#[derive(Debug, Clone, PartialEq)]
pub struct SwitchCase {
    pub test: Option<Expression>,
    pub body: Vec<Statement>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Program {
    pub body: Vec<Statement>,
}

/// 関数本体。大きな本体は解析せずにソースだけ持ち、初めて実行するときに解析する（遅延解析）。
///
/// 【2026-10-17】YouTube のアプリ JS（10.9MB）・player（3MB）は関数の大半が呼ばれないのに、
/// 全関数の構文木を作るとヒープ 512MB に収まらなかった。未解析の本体同士は入れ子に
/// ならない（外側を解析した時点で内側が作られる）ので、保持する文字列の合計はソース以下。
/// パーサは文脈（generator / async）に依存しないので、後から本体だけ解析しても結果は同じ。
pub struct FnBody {
    state: RefCell<FnBodyState>,
    /// strict モードの本体か（`"use strict"` の指令・strict な外側・クラス）。
    /// 非 strict の関数は this が undefined/null のときグローバル（window）になる。
    pub strict: bool,
    /// 本体（または内側のアロー関数）が `arguments` / `eval` を参照するか（0=未計算, 1=いいえ, 2=はい）。
    uses_args: core::cell::Cell<u8>,
}

enum FnBodyState {
    Parsed(Rc<Vec<Statement>>),
    Source { src: Rc<String>, calls: u8 },
}

impl FnBody {
    pub fn parsed(stmts: Vec<Statement>) -> Rc<Self> {
        Self::parsed_with(stmts, false)
    }

    pub fn parsed_with(stmts: Vec<Statement>, strict: bool) -> Rc<Self> {
        Rc::new(Self {
            state: RefCell::new(FnBodyState::Parsed(Rc::new(stmts))),
            strict,
            uses_args: core::cell::Cell::new(0),
        })
    }

    pub fn from_rc(stmts: Rc<Vec<Statement>>) -> Rc<Self> {
        Rc::new(Self {
            state: RefCell::new(FnBodyState::Parsed(stmts)),
            strict: false,
            uses_args: core::cell::Cell::new(0),
        })
    }

    pub fn lazy(source: String, strict: bool) -> Rc<Self> {
        Rc::new(Self {
            state: RefCell::new(FnBodyState::Source {
                src: Rc::new(source),
                calls: 0,
            }),
            strict,
            uses_args: core::cell::Cell::new(0),
        })
    }

    /// まだ解析していないか。
    pub fn is_lazy(&self) -> bool {
        matches!(&*self.state.borrow(), FnBodyState::Source { .. })
    }

    /// 本体の文（初回は構文木を保持せず返し、2 回目以降だけ構文木に置き換える）。
    ///
    /// 【2026-10-19】従来は 1 回呼ばれただけの関数でも構文木（ソース文字列の約 5〜8 倍の
    /// 大きさ）を `self.state` に永続保持していた。特に YouTube の `kevlar_base`（10.88MB）や
    /// `base.js`（2.97MB）の最外の即時関数は 1 回しか実行されないのに、約 40MB の構文木が
    /// クロージャ経由で最後まで残り続けていた。
    /// - 64KB 以上の巨大な本体（バンドル全体の即時関数など）は初回でソースも構文木も手放す。
    /// - それ以外は 1 回目の呼び出しではソースのまま残して構文木は呼び出し終了時に解放し、
    ///   2 回目に呼ばれた関数だけ構文木をキャッシュする。
    pub fn stmts(&self) -> Rc<Vec<Statement>> {
        enum Action {
            Cached(Rc<Vec<Statement>>),
            ParseOnce(Rc<String>),
            ParseAndDrop(Rc<String>),
            ParseAndCache(Rc<String>),
        }
        let action = {
            let mut b = self.state.borrow_mut();
            match &mut *b {
                FnBodyState::Parsed(s) => Action::Cached(s.clone()),
                FnBodyState::Source { src, calls } => {
                    if src.len() >= 65_536 {
                        let s = src.clone();
                        *b = FnBodyState::Parsed(Rc::new(Vec::new()));
                        Action::ParseAndDrop(s)
                    } else if *calls == 0 {
                        *calls = 1;
                        Action::ParseOnce(src.clone())
                    } else {
                        let s = src.clone();
                        *b = FnBodyState::Parsed(Rc::new(Vec::new()));
                        Action::ParseAndCache(s)
                    }
                }
            }
        };
        match action {
            Action::Cached(s) => s,
            Action::ParseOnce(src) => {
                Rc::new(super::parser::parse_function_body_source(&src, self.strict))
            }
            Action::ParseAndDrop(src) => {
                let parsed = Rc::new(super::parser::parse_function_body_source(&src, self.strict));
                drop(src);
                parsed
            }
            Action::ParseAndCache(src) => {
                let parsed = Rc::new(super::parser::parse_function_body_source(&src, self.strict));
                drop(src);
                *self.state.borrow_mut() = FnBodyState::Parsed(parsed.clone());
                parsed
            }
        }
    }

    /// この関数本体（および内側のアロー関数）が `arguments` または `eval` を参照するか。
    pub fn uses_arguments(&self, stmts: &[Statement]) -> bool {
        match self.uses_args.get() {
            1 => false,
            2 => true,
            _ => {
                let u = stmts_use_arguments(stmts);
                self.uses_args.set(if u { 2 } else { 1 });
                u
            }
        }
    }

    fn raw_might_use_arguments(&self) -> bool {
        match self.uses_args.get() {
            1 => false,
            2 => true,
            _ => match &*self.state.borrow() {
                FnBodyState::Source { src, .. } => {
                    src.contains("arguments") || src.contains("eval")
                }
                FnBodyState::Parsed(s) => {
                    let u = stmts_use_arguments(s);
                    self.uses_args.set(if u { 2 } else { 1 });
                    u
                }
            },
        }
    }
}

fn stmts_use_arguments(stmts: &[Statement]) -> bool {
    stmts.iter().any(stmt_uses_arguments)
}

fn stmt_uses_arguments(stmt: &Statement) -> bool {
    match stmt {
        Statement::Expression(e)
        | Statement::Return(Some(e))
        | Statement::Throw(e)
        | Statement::ExportDefault(e) => expr_uses_arguments(e),
        Statement::VarDeclaration { decls, .. } => decls
            .iter()
            .any(|(p, init)| pat_uses_arguments(p) || init.as_ref().is_some_and(expr_uses_arguments)),
        Statement::Block(b) => stmts_use_arguments(b),
        Statement::If {
            test,
            consequent,
            alternate,
        } => {
            expr_uses_arguments(test)
                || stmt_uses_arguments(consequent)
                || alternate.as_deref().is_some_and(stmt_uses_arguments)
        }
        Statement::While { test, body } | Statement::DoWhile { body, test } => {
            expr_uses_arguments(test) || stmt_uses_arguments(body)
        }
        Statement::For {
            init,
            test,
            update,
            body,
        } => {
            init.as_deref().is_some_and(stmt_uses_arguments)
                || test.as_ref().is_some_and(expr_uses_arguments)
                || update.as_ref().is_some_and(expr_uses_arguments)
                || stmt_uses_arguments(body)
        }
        Statement::ForIn {
            pattern,
            object,
            body,
            ..
        } => {
            pat_uses_arguments(pattern)
                || expr_uses_arguments(object)
                || stmt_uses_arguments(body)
        }
        Statement::Labeled(_, s) | Statement::ExportDecl { declaration: s, .. } => {
            stmt_uses_arguments(s)
        }
        Statement::Switch {
            discriminant,
            cases,
        } => {
            expr_uses_arguments(discriminant)
                || cases.iter().any(|c| {
                    c.test.as_ref().is_some_and(expr_uses_arguments)
                        || stmts_use_arguments(&c.body)
                })
        }
        Statement::Try {
            block,
            catch_param,
            catch_block,
            finally_block,
        } => {
            stmts_use_arguments(block)
                || catch_param.as_ref().is_some_and(pat_uses_arguments)
                || catch_block.as_deref().is_some_and(stmts_use_arguments)
                || finally_block.as_deref().is_some_and(stmts_use_arguments)
        }
        // 非アローの関数宣言は独自の `arguments` を持つため外側の `arguments` は参照しない。
        Statement::FunctionDeclaration { .. }
        | Statement::Return(None)
        | Statement::Break(_)
        | Statement::Continue(_)
        | Statement::Import { .. }
        | Statement::ExportNamed { .. }
        | Statement::ExportAll { .. }
        | Statement::Empty => false,
    }
}

fn pat_uses_arguments(pat: &Pattern) -> bool {
    match pat {
        Pattern::Identifier(n) => n == "arguments" || n == "eval",
        Pattern::Object(props) => props.iter().any(|p| {
            p.computed_key.as_ref().is_some_and(expr_uses_arguments)
                || pat_uses_arguments(&p.value)
                || p.default.as_ref().is_some_and(expr_uses_arguments)
        }),
        Pattern::Array(elems) => elems.iter().any(|e| {
            e.pattern.as_ref().is_some_and(pat_uses_arguments)
                || e.default.as_ref().is_some_and(expr_uses_arguments)
        }),
        Pattern::Expr(e) => expr_uses_arguments(e),
    }
}

fn expr_uses_arguments(expr: &Expression) -> bool {
    match expr {
        Expression::Identifier(n) => n == "arguments" || n == "eval",
        Expression::TemplateLiteral { exprs, .. } | Expression::Array(exprs) | Expression::Sequence(exprs) => {
            exprs.iter().any(expr_uses_arguments)
        }
        Expression::TaggedTemplate { tag, exprs, .. } => {
            expr_uses_arguments(tag) || exprs.iter().any(expr_uses_arguments)
        }
        Expression::Object(props) => props.iter().any(|p| {
            p.computed.as_ref().is_some_and(expr_uses_arguments) || expr_uses_arguments(&p.value)
        }),
        Expression::Function {
            params,
            body,
            is_arrow,
            ..
        } => {
            if !*is_arrow {
                false
            } else {
                params.iter().any(|p| {
                    pat_uses_arguments(&p.pattern)
                        || p.default.as_ref().is_some_and(expr_uses_arguments)
                }) || body.raw_might_use_arguments()
            }
        }
        Expression::Await(e)
        | Expression::Unary { expr: e, .. }
        | Expression::Update { target: e, .. }
        | Expression::Spread(e)
        | Expression::Member { object: e, .. } => expr_uses_arguments(e),
        Expression::Yield { argument, .. } => argument.as_deref().is_some_and(expr_uses_arguments),
        Expression::Binary { left, right, .. }
        | Expression::Logical { left, right, .. }
        | Expression::Assign {
            target: left,
            value: right,
            ..
        }
        | Expression::Index {
            object: left,
            index: right,
            ..
        } => expr_uses_arguments(left) || expr_uses_arguments(right),
        Expression::Conditional {
            test,
            consequent,
            alternate,
        } => {
            expr_uses_arguments(test)
                || expr_uses_arguments(consequent)
                || expr_uses_arguments(alternate)
        }
        Expression::Call {
            callee, arguments, ..
        }
        | Expression::New { callee, arguments } => {
            expr_uses_arguments(callee) || arguments.iter().any(expr_uses_arguments)
        }
        Expression::Class {
            superclass,
            members,
            ..
        } => {
            superclass.as_deref().is_some_and(expr_uses_arguments)
                || members.iter().any(|m| {
                    m.computed_key.as_ref().is_some_and(expr_uses_arguments)
                        || m.field_init.as_ref().is_some_and(expr_uses_arguments)
                })
        }
        Expression::Number(_)
        | Expression::BigIntLit(_)
        | Expression::Str(_)
        | Expression::Bool(_)
        | Expression::Null
        | Expression::Undefined
        | Expression::This
        | Expression::Super
        | Expression::NewTarget
        | Expression::Regex(..) => false,
    }
}

impl core::fmt::Debug for FnBody {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match &*self.state.borrow() {
            FnBodyState::Parsed(s) => write!(f, "FnBody({} stmts)", s.len()),
            FnBodyState::Source { src, .. } => write!(f, "FnBody(lazy {} chars)", src.len()),
        }
    }
}

/// 同じ本体（同じ定義）かどうかで比べる。
impl PartialEq for FnBody {
    fn eq(&self, other: &Self) -> bool {
        core::ptr::eq(self, other)
    }
}