atmos/os_lib/js/interp/

promise_loop.rs

// 分割: interp.rs の `impl Interp` から機械的に移動（2026-07-16 リファクタ フェーズ5）。
// ロジック不変。メソッド可視性のみ pub(crate) へ昇格（別モジュールの impl Interp
// からの self 呼び出しのため）。impl ブロックは型 Interp に自動で結合する。
use super::*;

impl Interp {
    /// Promise を解決する。値が Promise/thenable なら採用（チェーン）する。
    pub fn promise_resolve(&mut self, state: &Rc<RefCell<PromiseState>>, value: Value) {
        if state.borrow().status != PromiseStatus::Pending {
            return;
        }
        // Promise の採用: 内側が settle したら自身も settle。
        if let Value::Object(o) = &value {
            let inner = match &o.borrow().kind {
                ObjKind::PromiseObj(s) => Some(s.clone()),
                _ => None,
            };
            if let Some(inner) = inner {
                let on_f = Value::Object(Obj::resolver(state.clone(), false));
                let on_r = Value::Object(Obj::resolver(state.clone(), true));
                self.promise_then(&inner, Some(on_f), Some(on_r));
                return;
            }
        }
        // **重要**: 汎用 thenable（本物の Promise ではないが、呼び出し可能な `.then`
        // メソッドを持つ任意のオブジェクト。古いライブラリの独自 Promise 実装や
        // `{ then(resolve){ resolve(1) } }` のような手書きの thenable でよく使われる）
        // の同化（assimilation）が丸ごと未対応で、`Promise.resolve(thenable)`/
        // `await thenable` がそのオブジェクト自体を履行値にしてしまい、`.then` を
        // 一切呼ばずに終わっていたバグ。仕様どおり `thenable.then(resolve, reject)`
        // を呼び、その中での resolve/reject 呼び出しで自身を settle させる。
        if matches!(&value, Value::Object(_)) {
            // `o.borrow().props.get("then")` は own プロパティしか見ないため、
            // `class MyThenable { then(resolve){...} }` のようにメソッドが
            // `.prototype` 側にあるクラスインスタンスの thenable を取りこぼす
            // バグだった（自己検証で発見）。プロトタイプ連鎖を辿る通常のプロパティ
            // 解決 `get_property` を使う。
            let then_fn = self.get_property(&value, "then").unwrap_or(Value::Undefined);
            if matches!(&then_fn, Value::Object(f) if f.borrow().is_callable()) {
                let on_f = Value::Object(Obj::resolver(state.clone(), false));
                let on_r = Value::Object(Obj::resolver(state.clone(), true));
                if let Err(e) = self.call_value(&then_fn, value.clone(), &[on_f, on_r]) {
                    // thenable.then() 呼出し自体が例外を投げた場合は仕様どおり拒否。
                    self.promise_reject(state, e);
                }
                return;
            }
        }
        let reactions = {
            let mut b = state.borrow_mut();
            b.status = PromiseStatus::Fulfilled;
            b.value = value.clone();
            core::mem::take(&mut b.reactions)
        };
        for r in &reactions {
            self.schedule_reaction(r, value.clone(), true);
        }
    }

    /// Promise を拒否する。
    pub fn promise_reject(&mut self, state: &Rc<RefCell<PromiseState>>, reason: Value) {
        if state.borrow().status != PromiseStatus::Pending {
            return;
        }
        let reactions = {
            let mut b = state.borrow_mut();
            b.status = PromiseStatus::Rejected;
            b.value = reason.clone();
            core::mem::take(&mut b.reactions)
        };
        for r in &reactions {
            self.schedule_reaction(r, reason.clone(), false);
        }
    }

    /// then 反応を登録し、派生 Promise を返す。
    pub fn promise_then(
        &mut self,
        state: &Rc<RefCell<PromiseState>>,
        on_fulfilled: Option<Value>,
        on_rejected: Option<Value>,
    ) -> Value {
        let result = Rc::new(RefCell::new(PromiseState::pending()));
        let reaction = Reaction {
            on_fulfilled,
            on_rejected,
            result: result.clone(),
        };
        let status = state.borrow().status;
        match status {
            PromiseStatus::Pending => state.borrow_mut().reactions.push(reaction),
            PromiseStatus::Fulfilled => {
                let v = state.borrow().value.clone();
                self.schedule_reaction(&reaction, v, true);
            }
            PromiseStatus::Rejected => {
                let v = state.borrow().value.clone();
                self.schedule_reaction(&reaction, v, false);
            }
        }
        Value::Object(Obj::promise(result))
    }

    pub(crate) fn schedule_reaction(&self, reaction: &Reaction, value: Value, is_fulfill: bool) {
        let handler = if is_fulfill {
            reaction.on_fulfilled.clone()
        } else {
            reaction.on_rejected.clone()
        };
        self.microtasks.borrow_mut().push_back(Job {
            handler,
            arg: value,
            is_fulfill,
            result: reaction.result.clone(),
        });
    }

    /// マイクロタスクを 1 つ実行。実行したら true。
    pub(crate) fn run_one_microtask(&mut self) -> bool {
        let job = self.microtasks.borrow_mut().pop_front();
        let job = match job {
            Some(j) => j,
            None => return false,
        };
        match job.handler {
            Some(h) => match self.call_value(&h, Value::Undefined, &[job.arg]) {
                Ok(v) => self.promise_resolve(&job.result, v),
                Err(e) => {
                    if !self.aborted {
                        self.promise_reject(&job.result, e);
                    }
                }
            },
            None => {
                if job.is_fulfill {
                    self.promise_resolve(&job.result, job.arg);
                } else {
                    self.promise_reject(&job.result, job.arg);
                }
            }
        }
        true
    }

    /// 保留中のマイクロタスクを全て消化する。
    pub fn run_microtasks(&mut self) {
        while !self.aborted && self.run_one_microtask() {}
    }

    /// setTimeout コールバック（マクロタスク）を 1 つ実行。実行したら true。
    pub(crate) fn run_one_macrotask(&mut self) -> bool {
        let task = self.macrotasks.borrow_mut().pop_front();
        let (cb, args, _id) = match task {
            Some(t) => t,
            None => return false,
        };
        // setTimeout コールバック内の例外も捨てない（従来は完全に消えていた）。
        self.call_listener(&cb, Value::Undefined, &args, "setTimeout callback");
        true
    }

    /// setInterval コールバックを発火し、残回数をデクリメント。全完了なら true。
    pub(crate) fn run_intervals(&mut self) -> bool {
        if self.intervals.is_empty() {
            return false;
        }
        let ids: Vec<u64> = self.intervals.iter().map(|(id, _, _, _)| *id).collect();
        for id in ids {
            let entry = self.intervals.iter().position(|(i, _, _, _)| *i == id);
            if let Some(pos) = entry {
                let (_, cb, args, remaining) = self.intervals[pos].clone();
                if remaining == 0 {
                    self.intervals.remove(pos);
                    continue;
                }
                self.intervals[pos].3 -= 1;
                self.call_listener(&cb, Value::Undefined, &args, "setInterval callback");
            }
        }
        self.intervals.iter().any(|(_, _, _, r)| *r > 0)
    }

    /// イベントループ: マイクロタスクを消化 → マクロタスク 1 つ → インターバル → 繰り返す。
    pub fn run_event_loop(&mut self) {
        loop {
            self.run_microtasks();
            if self.aborted {
                break;
            }
            let has_macro = self.run_one_macrotask();
            let has_interval = self.run_intervals();
            if !has_macro && !has_interval {
                break;
            }
        }
    }

    /// await: 値が Promise ならマイクロタスクを駆動して解決まで進め、値を返す（reject は throw）。
    /// `using` の複数 dispose が例外を投げた場合に、新しい例外(`new_err`)と既存の
    /// 保留中の例外(`prev`)を `SuppressedError` へ集約する。`prev` が無ければ `new_err` を
    /// そのまま返す（グローバルに `SuppressedError` が無い異常系でも `new_err` へ安全にフォールバック）。
    pub(crate) fn chain_suppressed(&mut self, prev: Option<Value>, new_err: Value) -> Value {
        let Some(suppressed) = prev else {
            return new_err;
        };
        let Some(ctor) = scope_get(&self.global, "SuppressedError") else {
            return new_err;
        };
        self.call_value(&ctor, Value::Undefined, &[new_err.clone(), suppressed, Value::str("")])
            .unwrap_or(new_err)
    }

    pub(crate) fn await_value(&mut self, v: Value) -> EvalResult {
        let state = match &v {
            Value::Object(o) => match &o.borrow().kind {
                ObjKind::PromiseObj(s) => Some(s.clone()),
                _ => None,
            },
            _ => None,
        };
        // **重要**: `await` の仕様（Await 抽象操作は内部で PromiseResolve を呼ぶ）どおり、
        // 本物の Promise 以外の値（`.then` を持つ汎用 thenable を含む）も
        // `Promise.resolve()` と同じ経路に通す必要があるが、以前はここで即座に値を
        // そのまま返しており、`await { then(resolve){...} }` が `.then` を一切呼ばず
        // オブジェクト自体を結果にしてしまうバグだった（`Promise.resolve(thenable)`
        // 経由なら動くのに `await thenable` 直書きだけ非対称だった）。
        let state = match state {
            Some(s) => s,
            None => {
                let new_state = Rc::new(RefCell::new(PromiseState::pending()));
                self.promise_resolve(&new_state, v);
                new_state
            }
        };
        loop {
            let status = state.borrow().status;
            match status {
                PromiseStatus::Fulfilled => return Ok(state.borrow().value.clone()),
                PromiseStatus::Rejected => return Err(state.borrow().value.clone()),
                PromiseStatus::Pending => {
                    if self.aborted {
                        return Err(Value::Undefined);
                    }
                    // マイクロ→マクロ→インターバルの順で進める。すべて空なら解決不能。
                    let has_micro = self.run_one_microtask();
                    let has_macro = self.run_one_macrotask();
                    let has_interval = self.run_intervals();
                    if !has_micro && !has_macro && !has_interval {
                        return Ok(Value::Undefined);
                    }
                }
            }
        }
    }

}