atmos/os_lib/js/interp/

iter_gen.rs

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

impl Interp {
    /// for-in / for-of の列挙対象を Value のリストへ。
    /// generator は遅延駆動するため `&mut self` が必要。
    pub(crate) fn iterate_values(&mut self, obj: &Value, of: bool) -> Vec<Value> {
        // `Proxy` は自身が Array/Set/Map/Generator の種別を持たないため、素通しすると
        // 常に空になっていた（`for (const x of new Proxy([1,2,3], {}))` が何も回さない
        // バグ）。target フォワードのみの Proxy を想定し、先に target まで辿っておく。
        let obj = &{
            let mut cur = obj.clone();
            let mut guard = 0u32;
            loop {
                let next = match &cur {
                    Value::Object(o) => match &o.borrow().kind {
                        ObjKind::Proxy { target, .. } => Some(Value::Object(target.clone())),
                        _ => None,
                    },
                    _ => None,
                };
                match next {
                    // Proxy チェーンが循環参照（target が自分自身、または target 経由で
                    // 自分に戻ってくる）している場合、他のここでの全てのループ・再帰と
                    // 同様に上限で打ち切る。以前はガード無しで無限ループになり得た。
                    Some(v) if guard < 64 => {
                        cur = v;
                        guard += 1;
                    }
                    _ => break cur,
                }
            }
        };
        // generator は専用ドライバで全要素を取り出す（無限 gen はステップ予算で打ち切り）。
        if of {
            if let Value::Object(o) = obj {
                if matches!(&o.borrow().kind, ObjKind::Generator(_)) {
                    return self.drain_generator(o);
                }
            }
        }
        // ユーザー定義の `[Symbol.iterator](){}`（class 等で定義されるカスタムイテラブル）。
        // Array/Set/Map は専用の高速経路（下の match）を使うのでここでは対象外にする。
        // for-await の Symbol.asyncIterator 処理と同じ「iterator.next() を回して
        // {value,done} を読む」駆動方式（無限イテレータはステップ予算 tick() で打ち切る）。
        if of {
            if let Value::Object(o) = obj {
                let is_builtin = matches!(
                    &o.borrow().kind,
                    ObjKind::Array(_) | ObjKind::SetObj(_) | ObjKind::MapObj(_)
                );
                if !is_builtin {
                    let iter_method = self
                        .get_property(obj, "Symbol(Symbol.iterator)")
                        .unwrap_or(Value::Undefined);
                    if matches!(&iter_method, Value::Object(f) if f.borrow().is_callable()) {
                        let iterator = self
                            .call_value(&iter_method, obj.clone(), &[])
                            .unwrap_or(Value::Undefined);
                        let mut out = Vec::new();
                        loop {
                            if self.tick() {
                                break;
                            }
                            let next_fn = match self.get_property(&iterator, "next") {
                                Ok(v) => v,
                                Err(_) => break,
                            };
                            let result =
                                match self.call_value(&next_fn, iterator.clone(), &[]) {
                                    Ok(v) => v,
                                    Err(_) => break,
                                };
                            let done = self
                                .get_property(&result, "done")
                                .map(|v| v.truthy())
                                .unwrap_or(true);
                            if done {
                                break;
                            }
                            let value =
                                self.get_property(&result, "value").unwrap_or(Value::Undefined);
                            out.push(value);
                        }
                        return out;
                    }
                }
            }
        }
        match obj {
            Value::Object(o) => {
                let b = o.borrow();
                match &b.kind {
                    ObjKind::Array(items) => {
                        if of {
                            items.clone()
                        } else {
                            // for-in: インデックス文字列。
                            (0..items.len())
                                .map(|i| Value::str(i.to_string()))
                                .collect()
                        }
                    }
                    ObjKind::SetObj(_) | ObjKind::MapObj(_) if of => {
                        drop(b);
                        iterable_values(obj)
                    }
                    // `element.classList`（`DOMTokenList`）は仕様上イテラブルだが、専用の
                    // `Host("classList:N")` プロキシに `Symbol.iterator` が一切配線されて
                    // おらず、`for (const c of el.classList)`/`[...el.classList]` が常に
                    // 何も反復しないバグだった（`forEach()` の欠落と対）。
                    ObjKind::Host(t) if of && t.starts_with("classList:") => {
                        let cidx: usize = t.strip_prefix("classList:").and_then(|s| s.parse().ok()).unwrap_or(usize::MAX);
                        drop(b);
                        self.dom
                            .borrow()
                            .nodes
                            .get(cidx)
                            .map(|n| n.classes.iter().cloned().map(Value::str).collect())
                            .unwrap_or_default()
                    }
                    // `localStorage`/`sessionStorage` は実データを `.props` ではなく専用マップに
                    // 持つため、そちらを素通しすると `for (const k in localStorage)` が常に
                    // 何も回さないバグだった（`Object.keys(localStorage)` と同種）。仕様上
                    // Storage は for-of 対象（Symbol.iterator 実装）ではないため for-in のみ。
                    _ if !of && super::super::builtins::storage_host_keys(&b.kind).is_some() => {
                        super::super::builtins::storage_host_keys(&b.kind)
                            .unwrap_or_default()
                            .into_iter()
                            .map(Value::str)
                            .collect()
                    }
                    // `element.dataset` も同種のバグで `for (const k in el.dataset)` が
                    // 常に何も回さなかった（実データは DOM 要素側の `data-*` 属性）。
                    _ if !of
                        && super::super::builtins::dataset_host_keys(&b.kind, &self.dom.borrow())
                            .is_some() =>
                    {
                        super::super::builtins::dataset_host_keys(&b.kind, &self.dom.borrow())
                            .unwrap_or_default()
                            .into_iter()
                            .map(Value::str)
                            .collect()
                    }
                    _ => {
                        // for-in: キー名。for-of: 値。
                        if of {
                            b.props.values().cloned().collect()
                        } else {
                            // for-in は仕様上、自身のプロパティだけでなくプロトタイプ連鎖上の
                            // 列挙可能プロパティも辿る必要がある。以前は `b.props` (自身のみ)
                            // しか見ておらず、`Base.prototype.x=1` を継承した `new Derived()`
                            // に対する `for(k in d)` が継承プロパティを一切列挙しないバグだった。
                            // 同名キーは自身側を優先し、プロトタイプ側は１度だけ追加する。
                            // `accessors`（getter/setter 専用プロパティ）も `props` とは別
                            // マップのため、`in` 演算子の修正と同様にこちらも合わせて拾う。
                            // `Symbol.iterator` 等の well-known symbol はこの処理系では
                            // `"Symbol(...)"` という文字列キーで代用されているため
                            // （`is_symbol_like_key` 参照）、仕様どおり for-in の列挙対象
                            // から除外する。
                            let plain_keys: alloc::vec::Vec<(String, ())> = b
                                .props
                                .keys()
                                .filter(|k| !super::super::builtins::is_symbol_like_key(k))
                                .filter(|k| b.attrs.get(*k).copied().unwrap_or_default().enumerable)
                                .map(|k| (k.clone(), ()))
                                .collect();
                            let ordered_keys = super::super::builtins::spec_key_order(plain_keys);
                            let mut seen: alloc::collections::BTreeSet<String> = ordered_keys
                                .iter()
                                .map(|(k, _)| k.clone())
                                .collect();
                            let mut keys: alloc::vec::Vec<Value> = ordered_keys
                                .into_iter()
                                .map(|(k, _)| Value::str(k))
                                .collect();
                            for k in b.accessors.keys() {
                                if b.attrs.get(k).copied().unwrap_or_default().enumerable
                                    && seen.insert(k.clone())
                                {
                                    keys.push(Value::str(k.clone()));
                                }
                            }
                            let mut proto = b.proto.clone();
                            drop(b);
                            // `seen` はキーの重複除去のみを行い、循環プロトタイプ連鎖では
                            // ループ自体は止まらない。他の連鎖走査と同じ上限ガードで打ち切る。
                            let mut guard = 0u32;
                            while let Some(p) = proto {
                                guard += 1;
                                if guard > 1000 {
                                    break;
                                }
                                let pb = p.borrow();
                                for k in pb.props.keys().filter(|k| !super::super::builtins::is_symbol_like_key(k)) {
                                    if pb.attrs.get(k).copied().unwrap_or_default().enumerable
                                        && seen.insert(k.clone())
                                    {
                                        keys.push(Value::str(k.clone()));
                                    }
                                }
                                for k in pb.accessors.keys() {
                                    if pb.attrs.get(k).copied().unwrap_or_default().enumerable
                                        && seen.insert(k.clone())
                                    {
                                        keys.push(Value::str(k.clone()));
                                    }
                                }
                                proto = pb.proto.clone();
                            }
                            keys
                        }
                    }
                }
            }
            Value::Str(s) if of => s.chars().map(|c| Value::str(c.to_string())).collect(),
            _ => Vec::new(),
        }
    }

    // ============ Generator（遅延評価 / replay 駆動） ============

    /// 現在 generator 本体の中断処理中か（suspend 番兵 Err を try/catch が
    /// 捕捉しないようにするためのガード）。
    pub(crate) fn is_suspending(&self) -> bool {
        self.gen_replay
            .as_ref()
            .map(|r| r.suspending)
            .unwrap_or(false)
    }

    /// 現在 generator が強制Returnによる巻き戻し中か。
    pub(crate) fn is_gen_returning(&self) -> bool {
        self.gen_replay
            .as_ref()
            .map(|r| r.returning.is_some())
            .unwrap_or(false)
    }

    /// `yield value` の評価。replay 中でなければ無効（undefined）。
    /// target 番目の yield に達したら中断（suspend 番兵 Err を返す）。
    /// 既に通過済みの yield には保存済み resume 値を返して続行する。
    pub(crate) fn do_yield(&mut self, value: Value) -> EvalResult {
        let replay = match &mut self.gen_replay {
            Some(r) => r,
            None => return Ok(Value::Undefined),
        };
        let idx = replay.counter;
        replay.counter += 1;
        if idx < replay.target {
            // 通過済み: `.next(v)` なら resume 値を返して続行、`.throw(e)` ならこの
            // yield 式の位置で `e` を投げる（generator 本体の try/catch で捕捉され得る）。
            // `.return(v)` の場合は、強制Return例外（番兵）をスローし、`finally` の実行を促す。
            return match replay.sent.get(idx).cloned() {
                Some(super::super::value::GenCompletion::Normal(v)) => Ok(v),
                Some(super::super::value::GenCompletion::Throw(e)) => Err(e),
                Some(super::super::value::GenCompletion::Return(v)) => {
                    replay.returning = Some(v);
                    let sentinel = Value::Object(Obj::host("_gen_return"));
                    Err(sentinel)
                }
                None => Ok(Value::Undefined),
            };
        }
        // ここで中断。yield 値を記録し、suspend 番兵で最上位（resume）まで巻き戻す。
        replay.yielded = value;
        replay.suspending = true;
        Err(Value::Undefined)
    }

    /// Generator を 1 ステップ進める（`.next(sent)` 相当）。
    /// 戻り値は `(value, done)`。replay 方式で本体を先頭から再実行し、
    /// 次の yield まで進めて中断するか、本体完了で done:true を返す。
    pub fn generator_resume(
        &mut self,
        state: &Rc<RefCell<GenState>>,
        sent: Value,
    ) -> Result<(Value, bool), Value> {
        self.generator_resume_inner(state, super::super::value::GenCompletion::Normal(sent))
    }

    /// `.throw(err)` 相当: 現在中断中の yield 式の位置で `err` を投げて generator を
    /// 再開する（generator 本体の try/catch で捕捉されなければ、そのまま呼び出し元へ
    /// 伝播する）。
    pub fn generator_throw(
        &mut self,
        state: &Rc<RefCell<GenState>>,
        err: Value,
    ) -> Result<(Value, bool), Value> {
        // 仕様どおり、まだ一度も `.next()` していない generator への `.throw()` は
        // 本体を一切実行せず、そのまま例外として即座に伝播し generator を完了させる。
        let not_started = !state.borrow().started;
        if not_started {
            state.borrow_mut().done = true;
            return Err(err);
        }
        self.generator_resume_inner(state, super::super::value::GenCompletion::Throw(err))
    }

    /// `.return(val)` 相当: 現在中断中の yield 式の位置で return を発生させ、
    /// try...finally ブロック等を実行して generator を再開・完了させる。
    pub fn generator_return(
        &mut self,
        state: &Rc<RefCell<GenState>>,
        val: Value,
    ) -> Result<(Value, bool), Value> {
        let not_started = !state.borrow().started;
        if not_started {
            let mut b = state.borrow_mut();
            b.started = true;
            b.done = true;
            b.returned = val.clone();
            return Ok((val, true));
        }
        self.generator_resume_inner(state, super::super::value::GenCompletion::Return(val))
    }

    pub(crate) fn generator_resume_inner(
        &mut self,
        state: &Rc<RefCell<GenState>>,
        sent: super::super::value::GenCompletion,
    ) -> Result<(Value, bool), Value> {
        // 完了済みなら常に {undefined, done:true}（`.throw()` 経由なら例外をそのまま伝播）。
        {
            let b = state.borrow();
            if b.done {
                return match sent {
                    super::super::value::GenCompletion::Normal(_) => Ok((Value::Undefined, true)),
                    super::super::value::GenCompletion::Throw(e) => Err(e),
                    super::super::value::GenCompletion::Return(v) => Ok((v, true)),
                };
            }
        }
        // resume 結果を記録（最初の next の引数は捨てる）。target = 通過すべき yield 数。
        let (func, args, this, sent_vec) = {
            let mut b = state.borrow_mut();
            if b.started {
                b.sent.push(sent);
            } else {
                b.started = true;
            }
            (
                b.func.clone(),
                b.args.clone(),
                b.this.clone(),
                b.sent.clone(),
            )
        };
        let target = sent_vec.len();

        // 呼び出しスコープを毎回再構築（args/this は固定なので replay は決定的）。
        let call_scope = Scope::child(func.closure.clone());
        for (i, p) in func.params.iter().enumerate() {
            if p.is_rest {
                let rest_args: Vec<Value> = args.get(i..).map(|s| s.to_vec()).unwrap_or_default();
                self.bind_pattern(
                    &p.pattern,
                    Value::Object(Obj::array(rest_args)),
                    &call_scope,
                    &this,
                )?;
                break;
            }
            let mut v = args.get(i).cloned().unwrap_or(Value::Undefined);
            if matches!(v, Value::Undefined) {
                if let Some(def) = &p.default {
                    v = self.eval(def, &call_scope, &this)?;
                }
            }
            self.bind_pattern(&p.pattern, v, &call_scope, &this)?;
        }
        scope_declare(
            &call_scope,
            "arguments",
            Value::Object(Obj::array(args.clone())),
        );

        // replay 状態を差し込んで本体を実行（ネスト generator は save/restore で保護）。
        let saved = self.gen_replay.take();
        self.gen_replay = Some(GenReplay {
            sent: sent_vec.clone(),
            counter: 0,
            target,
            suspending: false,
            yielded: Value::Undefined,
            returning: None,
        });
        let outcome = self.exec_statements(&func.body, &call_scope, &this);
        let replay = self.gen_replay.take().unwrap_or(GenReplay {
            sent: Vec::new(),
            counter: 0,
            target,
            suspending: false,
            yielded: Value::Undefined,
            returning: None,
        });
        self.gen_replay = saved;

        // ステップ予算超過は最上位まで巻き戻す（generator も例外ではない）。
        if self.aborted {
            return Err(Value::Undefined);
        }
        if replay.suspending {
            // 中断: yield 値を返す（done:false）。状態は started/sent に保存済み。
            return Ok((replay.yielded, false));
        }

        // 強制Returnの巻き戻しが最後まで（あるいは finally に妨げられずに）到達した場合、
        // 且つ outcome が sentinel または正常完了（Ok）であれば、強制Returnの値を返す。
        if let Some(v) = &replay.returning {
            let is_sentinel = match &outcome {
                Err(Value::Object(o)) => matches!(&o.borrow().kind, ObjKind::Host(t) if t == "_gen_return"),
                _ => false,
            };
            if is_sentinel || outcome.is_ok() {
                let mut b = state.borrow_mut();
                b.done = true;
                b.returned = v.clone();
                return Ok((v.clone(), true));
            }
        }

        // 本体が完了した（これ以上 yield しない）。done:true。
        match outcome {
            Ok(Completion::Return(v)) => {
                let mut b = state.borrow_mut();
                b.done = true;
                b.returned = v.clone();
                Ok((v, true))
            }
            Ok(_) => {
                state.borrow_mut().done = true;
                Ok((Value::Undefined, true))
            }
            Err(e) => {
                // 本体内の throw: generator を完了扱いにして例外を伝播。
                state.borrow_mut().done = true;
                Err(e)
            }
        }
    }

    /// Generator を最後まで駆動して yield 値を Vec に集める（for-of / spread 用）。
    /// 無限 generator はステップ予算超過（aborted）で打ち切られる。
    pub(crate) fn drain_generator(&mut self, gen: &ObjRef) -> Vec<Value> {
        let state = match &gen.borrow().kind {
            ObjKind::Generator(g) => g.clone(),
            _ => return Vec::new(),
        };
        let mut out = Vec::new();
        loop {
            if self.aborted {
                break;
            }
            match self.generator_resume(&state, Value::Undefined) {
                Ok((_, true)) => break,
                Ok((v, false)) => out.push(v),
                Err(_) => break,
            }
        }
        out
    }

    /// イテラブルを Value 列に展開する。generator は遅延駆動する。
    /// `iterable_values`（純関数）の generator 対応版。
    pub fn iter_to_vec(&mut self, v: &Value) -> Vec<Value> {
        // `iterate_values(_, true)` は Generator の専用ドライバ・ユーザー定義
        // `[Symbol.iterator]()` カスタムイテラブル・Array/Set/Map/文字列を一通り
        // カバーするので、スプレッド構文（`[...x]`/関数呼出の `...x`）もこれに委譲する。
        self.iterate_values(v, true)
    }

    // ============ 式 ============

}