atmos/os_lib/js/builtins/

errors_misc.rs

// 分割: builtins.rs より機械的に移動（2026-07-16 リファクタ フェーズ2）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

// ===== Error 階層（Error / TypeError / RangeError / SyntaxError）=====
// `new` 経由なら `construct_object` が `this`（`t`）に既にコンストラクタの `.prototype` を
// proto として設定済みなので、それを使い回して message/name を書き込む
// （`new TypeError() instanceof Error` 等が成立するのはこの proto 連鎖のおかげ）。
// `new` を介さない素の呼び出し（`Error(msg)` 等）では `t` がオブジェクトでないため、
// 独立したプレーンオブジェクトへフォールバックする（proto 無しの簡略動作）。
/// `name`/`message` から `Error.prototype.stack` の値を組み立てる。この処理系は
/// ツリーウォーク評価器で呼び出しフレームスタックを保持していないため、実際の
/// コールスタックのフレーム一覧は再現できない（V8 等が返す複数行のトレースは
/// 非対応）。多くの実用コードは「`.stack` が空でない文字列で、エラー内容の説明で
/// 始まる」ことしか当てにしないため、V8 の1行目と同じ `"{name}: {message}"`
/// 形式（`message` 空なら `name` のみ）を返す簡略実装とする
/// （2026-07-14、丸ごと未対応だったのを発見・実装）。
pub(crate) fn build_error_stack(name: &str, msg: &str) -> String {
    if msg.is_empty() {
        String::from(name)
    } else {
        alloc::format!("{name}: {msg}")
    }
}
pub(crate) fn set_error_props(it: &Interp, t: Value, msg: String, name: &str) -> Value {
    match &t {
        Value::Object(o) => {
            let mut b = o.borrow_mut();
            b.props.insert("stack".into(), Value::str(build_error_stack(name, &msg)));
            b.props.insert("message".into(), Value::str(msg));
            b.props.insert("name".into(), Value::str(name));
            drop(b);
            t
        }
        _ => {
            // `new` を介さない素の呼び出し。`it.error()` と同じ経路で proto を
            // `Error.prototype` に繋いでおく（`new` 経由と挙動を揃える）。
            let stack = build_error_stack(name, &msg);
            let err = it.error(msg);
            if let Value::Object(o) = &err {
                let mut b = o.borrow_mut();
                b.props.insert("name".into(), Value::str(name));
                b.props.insert("stack".into(), Value::str(stack));
            }
            err
        }
    }
}
/// `new Error(msg, {cause})`（ES2022 のエラーオプション。原因となった別の例外を連鎖させる
/// 定番イディオム `catch(e){ throw new Error('wrap', {cause: e}) }` で使われる）。
/// `options` が `cause` プロパティを（値に関わらず）持つ場合のみ `err.cause` を設定する
/// （`in` 相当。`cause` キー自体が無ければ設定しない、が仕様上の挙動）。
pub(crate) fn apply_error_cause(err: &Value, options: &Value) -> Value {
    if let Value::Object(opt_obj) = options {
        let has_cause = opt_obj.borrow().props.contains_key("cause");
        if has_cause {
            let cause = opt_obj.borrow().props.get("cause").cloned().unwrap_or(Value::Undefined);
            if let Value::Object(o) = err {
                o.borrow_mut().props.insert("cause".into(), cause);
            }
        }
    }
    err.clone()
}
pub(crate) fn error_ctor(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let err = set_error_props(it, t, arg(a, 0).to_js_string(), "Error");
    Ok(apply_error_cause(&err, &arg(a, 1)))
}
pub(crate) fn type_error_ctor(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let err = set_error_props(it, t, arg(a, 0).to_js_string(), "TypeError");
    Ok(apply_error_cause(&err, &arg(a, 1)))
}
pub(crate) fn range_error_ctor(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let err = set_error_props(it, t, arg(a, 0).to_js_string(), "RangeError");
    Ok(apply_error_cause(&err, &arg(a, 1)))
}
pub(crate) fn syntax_error_ctor(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let err = set_error_props(it, t, arg(a, 0).to_js_string(), "SyntaxError");
    Ok(apply_error_cause(&err, &arg(a, 1)))
}
/// `SuppressedError(error, suppressed, message)`（ES2023→ES2026、`using` の複数 dispose 失敗を
/// 集約するための型）。`error`/`suppressed` プロパティを持つ Error オブジェクトを返す。
pub(crate) fn suppressed_error_ctor(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let err = set_error_props(it, t, arg(a, 2).to_js_string(), "SuppressedError");
    if let Value::Object(o) = &err {
        let mut b = o.borrow_mut();
        b.props.insert("error".into(), arg(a, 0));
        b.props.insert("suppressed".into(), arg(a, 1));
    }
    Ok(err)
}
/// `new AggregateError(errors, message)`（ES2021）が丸ごと欠落していた。`Promise.any` が
/// 全て reject したときに投げるべき例外型で、`.errors`（全 reject 理由の配列）を持つ。
pub(crate) fn aggregate_error_ctor(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let errors_list = it.iter_to_vec(&arg(a, 0));
    let msg = arg(a, 1).to_js_string();
    let err = set_error_props(it, t, msg, "AggregateError");
    if let Value::Object(o) = &err {
        o.borrow_mut().props.insert("errors".into(), Value::Object(Obj::array(errors_list)));
    }
    Ok(err)
}
/// `Error.isError(value)`（ES2025）。`value instanceof Error` と違い、`Symbol.hasInstance`
/// の上書きや `Error.prototype` の差し替えに影響されず、常に組込み `error_proto` を
/// proto 連鎖から探す（`instanceof` と同じ仕組みを使うが対象を固定 proto に限定）。
/// これが本来の存在意義（他レルムの Error でも正しく判定できる）に近い、単一レルムの
/// この処理系での妥当な近似実装。
pub(crate) fn error_is_error(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let error_proto = match it.global.borrow().vars.get("Error") {
        Some(Value::Object(ctor)) => match ctor.borrow().props.get("prototype") {
            Some(Value::Object(p)) => Some(p.clone()),
            _ => None,
        },
        _ => None,
    };
    let error_proto = match error_proto {
        Some(p) => p,
        None => return Ok(Value::Bool(false)),
    };
    let mut cur = match arg(a, 0) {
        Value::Object(o) => Some(o),
        _ => None,
    };
    let mut guard = 0;
    while let Some(c) = cur {
        if Rc::ptr_eq(&c, &error_proto) {
            return Ok(Value::Bool(true));
        }
        cur = c.borrow().proto.clone();
        guard += 1;
        if guard > 1000 {
            break;
        }
    }
    Ok(Value::Bool(false))
}
/// Rust 側（`Promise.any` の内部実装）から直接 `AggregateError` インスタンスを組み立てる
/// ヘルパ。`new` 式を経由できないため、`AggregateError` のプロトタイプへ手動で繋ぐ。
pub(crate) fn make_aggregate_error(it: &Interp, errors: Vec<Value>, msg: &str) -> Value {
    let o = Obj::plain();
    o.borrow_mut().props.insert("message".into(), Value::str(msg));
    o.borrow_mut().props.insert("name".into(), Value::str("AggregateError"));
    o.borrow_mut().props.insert("errors".into(), Value::Object(Obj::array(errors)));
    if let Some(Value::Object(ctor)) = it.global.borrow().vars.get("AggregateError") {
        if let Some(Value::Object(proto)) = ctor.borrow().props.get("prototype") {
            o.borrow_mut().proto = Some(proto.clone());
        }
    }
    Value::Object(o)
}

// ===== FinalizationRegistry（GC 非搭載 → register は no-op）=====
pub(crate) fn fr_register(_: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}
pub(crate) fn fr_unregister(_: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(false))
}
pub(crate) fn finalization_registry_ctor(_: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let cb = arg(a, 0);
    let obj = Obj::plain();
    {
        let mut b = obj.borrow_mut();
        b.props.insert("_cb".into(), cb);
        b.props.insert("register".into(), nv("register", fr_register));
        b.props.insert("unregister".into(), nv("unregister", fr_unregister));
        b.props.insert("cleanupSome".into(), nv("cleanupSome", dom_noop));
    }
    Ok(Value::Object(obj))
}

// ===== requestIdleCallback（即時発火。IdleDeadline.timeRemaining() → 50ms 固定）=====
pub(crate) fn idle_time_remaining(_: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Number(50.0))
}
pub(crate) fn request_idle_callback(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let cb = arg(a, 0);
    let deadline = Obj::plain();
    {
        let mut b = deadline.borrow_mut();
        b.props.insert("didTimeout".into(), Value::Bool(false));
        b.props.insert("timeRemaining".into(), nv("timeRemaining", idle_time_remaining));
    }
    it.call_listener(
        &cb,
        Value::Undefined,
        &[Value::Object(deadline)],
        "requestIdleCallback callback",
    );
    Ok(Value::Number(0.0))
}

// ===== Object.hasOwn（Object.prototype.hasOwnProperty の静的版）=====
pub(crate) fn object_has_own_static(_: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let obj = arg(a, 0);
    let key = arg(a, 1).to_js_string();
    if let Value::Object(o) = &obj {
        return Ok(Value::Bool(has_own_property(o, &key)));
    }
    Ok(Value::Bool(false))
}

// ===== Object.groupBy（配列→キー関数でグループ化。ES2024）=====
pub(crate) fn object_group_by(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = it.iter_to_vec(&arg(a, 0));
    let f = arg(a, 1);
    let result = Obj::plain();
    // 仕様上`Object.groupBy`の戻り値は`[[Prototype]]`が`null`のオブジェクト
    // （`OrdinaryObjectCreate(null)`）。2026-07-18 発見・実装。
    result.borrow_mut().null_proto = true;
    for (i, v) in items.iter().enumerate() {
        let key = it
            .call_value(&f, Value::Undefined, &[v.clone(), Value::Number(i as f64)])?
            .to_js_string();
        let mut b = result.borrow_mut();
        let entry = b
            .props
            .entry(key)
            .or_insert_with(|| Value::Object(Obj::array(alloc::vec![])));
        if let Value::Object(arr) = entry {
            if let ObjKind::Array(vec) = &mut arr.borrow_mut().kind {
                vec.push(v.clone());
            }
        }
    }
    Ok(Value::Object(result))
}

/// `Map.groupBy(items, callbackFn)`（ES2024）。`Object.groupBy` と異なりキーを文字列化せず、
/// 任意の値（オブジェクト・数値等）をそのままキーにできる（`same_value_zero` で同一性判定）。
pub(crate) fn map_group_by(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let items: Vec<Value> = it.iter_to_vec(&arg(a, 0));
    let f = arg(a, 1);
    let mut entries: Vec<(Value, Value)> = Vec::new();
    for (i, v) in items.iter().enumerate() {
        let key = it.call_value(&f, Value::Undefined, &[v.clone(), Value::Number(i as f64)])?;
        if let Some(slot) = entries.iter_mut().find(|(ek, _)| same_value_zero(ek, &key)) {
            if let Value::Object(arr) = &slot.1 {
                if let ObjKind::Array(vec) = &mut arr.borrow_mut().kind {
                    vec.push(v.clone());
                }
            }
        } else {
            entries.push((key, Value::Object(Obj::array(alloc::vec![v.clone()]))));
        }
    }
    Ok(Value::Object(Obj::map_obj(entries)))
}