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 timer_now(&self) -> u64 {
        crate::kernel::timer::get_system_time_ms().wrapping_add(self.clock_skew.get())
    }

    /// タイマーを 1 つ実行する。`force` なら期限前でも最も早いものを実行する（同期 await の進行用）。
    /// 期限の早い順、同じなら登録順。setInterval は呼ぶ前に次の予定を積み直す（コールバック内の
    /// clearInterval で消せるように）。実行したら true。
    pub(crate) fn run_timer(&mut self, force: bool) -> bool {
        let now = self.timer_now();
        let task = {
            let mut q = self.macrotasks.borrow_mut();
            let idx = q
                .iter()
                .enumerate()
                .filter(|(_, t)| force || t.due_ms <= now)
                .min_by_key(|(i, t)| (t.due_ms, *i))
                .map(|(i, _)| i);
            idx.and_then(|i| q.remove(i))
        };
        let Some(t) = task else { return false };
        if force && t.due_ms > now {
            // 期限前に実行する分だけ時刻を進める（後続のタイマーとの順序を保つ）。
            self.clock_skew.set(self.clock_skew.get().wrapping_add(t.due_ms - now));
        }
        if let Some(p) = t.period_ms {
            let mut next = t.clone();
            next.due_ms = t.due_ms.max(now).wrapping_add(p.max(1));
            self.macrotasks.borrow_mut().push_back(next);
        }
        let ctx = if t.period_ms.is_some() { "setInterval callback" } else { "setTimeout callback" };
        self.call_listener(&t.cb, Value::Undefined, &t.args, ctx);
        true
    }

    /// 互換: 期限の来たタイマーを 1 つ実行する。
    pub(crate) fn run_one_macrotask(&mut self) -> bool {
        self.run_timer(false)
    }

    /// 期限の来たタイマーがあるか。
    pub fn has_due_timer(&self) -> bool {
        let now = self.timer_now();
        self.macrotasks.borrow().iter().any(|t| t.due_ms <= now)
    }

    /// イベントループ: マイクロタスクを消化 → 期限の来たタイマー 1 つ → 繰り返す。
    /// `budget_ms` を使い切るか期限の来たタイマーが無くなれば戻る（残りは次の呼び出しで）。
    pub fn run_event_loop_for(&mut self, budget_ms: u64) {
        let start = crate::kernel::timer::get_system_time_ms();
        loop {
            self.run_microtasks();
            if self.aborted {
                break;
            }
            if crate::kernel::timer::get_system_time_ms().wrapping_sub(start) > budget_ms {
                break;
            }
            if !self.run_timer(false) {
                break;
            }
        }
    }

    /// スクリプト評価直後のイベントループ（期限の来たタイマーを最大 300ms 分）。
    pub fn run_event_loop(&mut self) {
        self.run_event_loop_for(300);
    }

    /// 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);
                    }
                    // マイクロ → タイマーの順で進める。この処理系の await は同期実行なので、期限前の
                    // タイマーも時刻を早送りして実行する。すべて空なら解決不能。
                    let has_micro = self.run_one_microtask();
                    let has_macro = !has_micro && self.run_timer(true);
                    if !has_micro && !has_macro {
                        return Ok(Value::Undefined);
                    }
                }
            }
        }
    }

}