From 1765d567a19a169b3ece9fc81e52c6b9a0d36a7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=88=B1=E7=89=B9=E6=AF=8F=E7=BE=8A=E9=98=9F?= Date: Mon, 10 Aug 2026 18:18:39 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20Temporal=20=E6=9C=80=E5=B0=8F=E5=AD=90?= =?UTF-8?q?=E9=9B=86=EF=BC=88Temporal.Now/Instant/PlainDate/PlainTime?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_builtins/src/lib.rs | 2 + crates/oxide_builtins/src/temporal.rs | 464 ++++++++++++++++++ crates/oxide_kernel/src/builtin.rs | 80 ++- crates/oxide_kernel/src/kernel.rs | 28 +- crates/oxide_types/src/object.rs | 21 + crates/oxide_vm/src/bindings/bind_temporal.rs | 194 ++++++++ crates/oxide_vm/src/bindings/mod.rs | 6 + .../oxide_vm/tests/builtins_temporal_tests.rs | 242 +++++++++ 8 files changed, 1035 insertions(+), 2 deletions(-) create mode 100644 crates/oxide_builtins/src/temporal.rs create mode 100644 crates/oxide_vm/src/bindings/bind_temporal.rs create mode 100644 crates/oxide_vm/tests/builtins_temporal_tests.rs diff --git a/crates/oxide_builtins/src/lib.rs b/crates/oxide_builtins/src/lib.rs index 2c68706..3c5b849 100644 --- a/crates/oxide_builtins/src/lib.rs +++ b/crates/oxide_builtins/src/lib.rs @@ -49,5 +49,7 @@ pub mod string; pub mod stubs; /// Symbol 内置对象实现（constructor/for/keyFor/toString）。 pub mod symbol; +/// Temporal 内置对象实现（Now/Instant/PlainDate/PlainTime 最小子集）。 +pub mod temporal; /// TypedArray 内置对象实现（元素访问、fill/slice/subarray/set 等）。 pub mod typed_array; diff --git a/crates/oxide_builtins/src/temporal.rs b/crates/oxide_builtins/src/temporal.rs new file mode 100644 index 0000000..c4abb94 --- /dev/null +++ b/crates/oxide_builtins/src/temporal.rs @@ -0,0 +1,464 @@ +use chrono::{DateTime, Datelike, NaiveDate, SecondsFormat, Utc}; + +use oxide_kernel::shape_forge::EMPTY_SHAPE_ID; +use oxide_runtime_api::{to_number, to_string, NativeResult, VmHost}; +use oxide_types::object::JsObject; +use oxide_types::value::JsValue; + +// Temporal 命名空间的最小实现子集：Temporal.Now / Temporal.Instant / +// Temporal.PlainDate / Temporal.PlainTime。内部数据按对象类型存入 prop 槽： +// Instant 存纪元纳秒（f64，prop 0）、PlainDate 存年/月/日（prop 0-2）、 +// PlainTime 存午夜后纳秒（f64，prop 0）。 + +macro_rules! native_try { + ($expr:expr) => { + match $expr { + Ok(value) => value, + Err(err) => return NativeResult::Err(err), + } + }; +} + +fn get_double_prop(obj: &JsObject, pos: usize) -> f64 { + let v = obj.get_prop_at(pos); + if v.is_double() { + v.as_double() + } else { + f64::NAN + } +} + +fn ensure_instant(vm: &mut H, obj: &JsObject) -> Result<(), JsValue> { + if !obj.is_instant_obj() { + return Err(crate::error::create_type_error(vm, "called on incompatible receiver")); + } + Ok(()) +} + +fn ensure_plain_date(vm: &mut H, obj: &JsObject) -> Result<(), JsValue> { + if !obj.is_plain_date_obj() { + return Err(crate::error::create_type_error(vm, "called on incompatible receiver")); + } + Ok(()) +} + +fn ensure_plain_time(vm: &mut H, obj: &JsObject) -> Result<(), JsValue> { + if !obj.is_plain_time_obj() { + return Err(crate::error::create_type_error(vm, "called on incompatible receiver")); + } + Ok(()) +} + +fn receiver_obj(vm: &mut H, args: &[u8]) -> Result<*mut JsObject, JsValue> { + let raw = vm.reg(if args.is_empty() { 0 } else { args[0] }); + if !raw.is_object() { + return Err(crate::error::create_type_error(vm, "called on incompatible receiver")); + } + let ptr = raw.as_js_object_ptr(); + if ptr.is_null() { + return Err(crate::error::create_type_error(vm, "called on incompatible receiver")); + } + Ok(ptr) +} + +/// 读 receiver 是否为构造调用：`new` 时 this 的原型是相应构造器的 prototype。 +fn is_ctor_call(vm: &mut H, args: &[u8], proto_ptr: *const JsObject) -> bool { + let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] }); + if !this_val.is_object() { + return false; + } + let ptr = this_val.as_js_object_ptr(); + if ptr.is_null() { + return false; + } + let obj = unsafe { &*ptr }; + let this_proto = obj.proto().as_js_object_ptr(); + !this_proto.is_null() && std::ptr::eq(this_proto, proto_ptr) +} + +fn make_instant(vm: &mut H, epoch_ns: i128) -> NativeResult { + let proto = JsValue::from_js_object(vm.session().builtin_world().instant_proto.as_ptr() as *mut JsObject); + let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, proto); + obj.type_tag = JsObject::OBJ_TYPE_INSTANT; + obj.set_prop_at(0, JsValue::float(epoch_ns as f64)); + NativeResult::Ok(JsValue::from_js_object(vm.alloc_object(obj))) +} + +/// 把 epoch 纳秒拆成秒 + 亚秒纳秒（供 chrono 时间转换）。 +fn ns_to_datetime(epoch_ns: f64) -> Option> { + if !epoch_ns.is_finite() { + return None; + } + let secs = (epoch_ns / 1e9).trunc() as i64; + let sub_ns = (epoch_ns - (epoch_ns / 1e9).trunc() * 1e9).round() as u32; + DateTime::from_timestamp(secs, sub_ns) +} + +/// 解析 `YYYY-MM-DDTHH:MM:SS[.fff](Z|±HH:MM)` 形式的 ISO 字符串到纪元纳秒。 +fn parse_instant_string(s: &str) -> Option { + let t = s.trim(); + let dt = DateTime::parse_from_rfc3339(t).ok()?; + let utc = dt.with_timezone(&Utc); + Some(utc.timestamp() as i128 * 1_000_000_000 + utc.timestamp_subsec_nanos() as i128) +} + +/// `Temporal.Now.instant()`：返回当前时刻的 Temporal.Instant。 +pub fn now_instant(vm: &mut H, _args: &[u8]) -> NativeResult { + let now = Utc::now(); + let epoch_ns = now.timestamp() as i128 * 1_000_000_000 + now.timestamp_subsec_nanos() as i128; + make_instant(vm, epoch_ns) +} + +/// `Temporal.Now.timeZoneId()`：引擎固定使用 UTC。 +pub fn now_time_zone_id(vm: &mut H, _args: &[u8]) -> NativeResult { + NativeResult::Ok(vm.new_string("UTC")) +} + +/// `Temporal.Instant` 构造器：接受一个数值（纪元纳秒，BigInt 未实现故按 number 处理）。 +pub fn instant_constructor(vm: &mut H, args: &[u8]) -> NativeResult { + let ctor_proto = vm.session().builtin_world().instant_proto.as_ptr(); + if !is_ctor_call(vm, args, ctor_proto) { + return NativeResult::Err(crate::error::create_type_error( + vm, + "Class constructor Temporal.Instant cannot be invoked without 'new'", + )); + } + let epoch_ns = if args.len() < 2 { + 0.0 + } else { + to_number(vm.reg(args[1])) + }; + make_instant(vm, epoch_ns as i128) +} + +/// `Temporal.Instant.from(value)`：接受 ISO 字符串、数值（纪元纳秒）或 +/// 带 `epochMilliseconds`/`epochNanoseconds` 数值字段的对象。 +pub fn instant_from(vm: &mut H, args: &[u8]) -> NativeResult { + let val = if args.len() < 2 { JsValue::undefined() } else { vm.reg(args[1]) }; + let epoch_ns = if val.is_string() { + let s = to_string(val); + match parse_instant_string(&s) { + Some(ns) => ns, + None => { + return NativeResult::Err(crate::error::create_range_error(vm, "invalid ISO 8601 string")); + } + } + } else if val.is_int() || val.is_double() { + to_number(val) as i128 + } else if val.is_object() && { + let ptr = val.as_js_object_ptr(); + !ptr.is_null() && unsafe { &*ptr }.is_instant_obj() + } { + let obj = unsafe { &*val.as_js_object_ptr() }; + get_double_prop(obj, 0) as i128 + } else if val.is_object() { + let obj = unsafe { &*val.as_js_object_ptr() }; + let obj_val = val; + let ms = read_prop_number(vm, obj, obj_val, "epochMilliseconds"); + let ns = read_prop_number(vm, obj, obj_val, "epochNanoseconds"); + if !ns.is_nan() { + ns as i128 + } else if !ms.is_nan() { + (ms * 1e6) as i128 + } else { + return NativeResult::Err(crate::error::create_type_error(vm, "cannot convert object to Instant")); + } + } else { + return NativeResult::Err(crate::error::create_type_error(vm, "cannot convert value to Instant")); + }; + make_instant(vm, epoch_ns) +} + +/// 读对象的数值字段（普通对象访问器 getter 路径）。 +fn read_prop_number(vm: &mut H, obj: &JsObject, receiver: JsValue, name: &str) -> f64 { + let key_val = vm.new_string(name); + let si = vm.property_key_si(key_val); + vm.ordinary_get(obj, si, receiver).map(to_number).unwrap_or(f64::NAN) +} + +/// `Temporal.Instant.prototype.epochSeconds` getter。 +pub fn instant_epoch_seconds(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_instant(vm, obj)); + NativeResult::Ok(JsValue::float((get_double_prop(obj, 0) / 1e9).trunc())) +} + +/// `Temporal.Instant.prototype.epochMilliseconds` getter。 +pub fn instant_epoch_milliseconds(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_instant(vm, obj)); + NativeResult::Ok(JsValue::float((get_double_prop(obj, 0) / 1e6).trunc())) +} + +/// `Temporal.Instant.prototype.epochMicroseconds` getter。 +pub fn instant_epoch_microseconds(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_instant(vm, obj)); + NativeResult::Ok(JsValue::float((get_double_prop(obj, 0) / 1e3).trunc())) +} + +/// `Temporal.Instant.prototype.epochNanoseconds` getter：BigInt 未实现，返回 number 近似。 +pub fn instant_epoch_nanoseconds(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_instant(vm, obj)); + NativeResult::Ok(JsValue::float(get_double_prop(obj, 0))) +} + +/// `Temporal.Instant.prototype.toString()`：输出 ISO 8601 UTC（如 `2024-01-01T00:00:00Z`）。 +pub fn instant_to_string(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_instant(vm, obj)); + match ns_to_datetime(get_double_prop(obj, 0)) { + Some(dt) => { + let s = dt.to_rfc3339_opts(SecondsFormat::AutoSi, true); + NativeResult::Ok(vm.new_string(&s)) + } + None => NativeResult::Err(crate::error::create_range_error(vm, "invalid Instant")), + } +} + +/// `Temporal.Instant.prototype.valueOf()`：Temporal 对象禁止转原始值。 +pub fn instant_value_of(vm: &mut H, _args: &[u8]) -> NativeResult { + NativeResult::Err(crate::error::create_type_error(vm, "Temporal.Instant has no valueOf")) +} + +fn make_plain_date(vm: &mut H, year: i32, month: u32, day: u32) -> NativeResult { + let proto = + JsValue::from_js_object(vm.session().builtin_world().plain_date_proto.as_ptr() as *mut JsObject); + let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, proto); + obj.type_tag = JsObject::OBJ_TYPE_PLAIN_DATE; + obj.set_prop_at(0, JsValue::float(year as f64)); + obj.set_prop_at(1, JsValue::float(month as f64)); + obj.set_prop_at(2, JsValue::float(day as f64)); + NativeResult::Ok(JsValue::from_js_object(vm.alloc_object(obj))) +} + +/// 校验 ISO 日期分量（month 1-12、day 按月份与闰年）。 +fn valid_iso_date(year: i32, month: u32, day: u32) -> bool { + NaiveDate::from_ymd_opt(year, month, day).is_some() +} + +fn parse_plain_date_string(s: &str) -> Option<(i32, u32, u32)> { + let t = s.trim(); + NaiveDate::parse_from_str(t, "%Y-%m-%d").ok().map(|d| { + let (y, m, day) = (d.year(), d.month(), d.day()); + (y, m, day) + }) +} + +/// `Temporal.PlainDate` 构造器：`new PlainDate(year, month, day)`。 +pub fn plain_date_constructor(vm: &mut H, args: &[u8]) -> NativeResult { + let ctor_proto = vm.session().builtin_world().plain_date_proto.as_ptr(); + if !is_ctor_call(vm, args, ctor_proto) { + return NativeResult::Err(crate::error::create_type_error( + vm, + "Class constructor Temporal.PlainDate cannot be invoked without 'new'", + )); + } + let year = if args.len() > 1 { to_number(vm.reg(args[1])).trunc() as i32 } else { 0 }; + let month = if args.len() > 2 { to_number(vm.reg(args[2])).trunc() as u32 } else { 1 }; + let day = if args.len() > 3 { to_number(vm.reg(args[3])).trunc() as u32 } else { 1 }; + if !valid_iso_date(year, month, day) { + return NativeResult::Err(crate::error::create_range_error(vm, "invalid ISO date")); + } + make_plain_date(vm, year, month, day) +} + +/// `Temporal.PlainDate.from(value)`：接受 `YYYY-MM-DD` 字符串或 `{year, month, day}` 对象。 +pub fn plain_date_from(vm: &mut H, args: &[u8]) -> NativeResult { + let val = if args.len() < 2 { JsValue::undefined() } else { vm.reg(args[1]) }; + let (year, month, day) = if val.is_string() { + let s = to_string(val); + match parse_plain_date_string(&s) { + Some(ymd) => ymd, + None => { + return NativeResult::Err(crate::error::create_range_error(vm, "invalid ISO 8601 date")); + } + } + } else if val.is_object() && { + let ptr = val.as_js_object_ptr(); + !ptr.is_null() && unsafe { &*ptr }.is_plain_date_obj() + } { + let obj = unsafe { &*val.as_js_object_ptr() }; + ( + get_double_prop(obj, 0) as i32, + get_double_prop(obj, 1) as u32, + get_double_prop(obj, 2) as u32, + ) + } else if val.is_object() { + let obj = unsafe { &*val.as_js_object_ptr() }; + let y = read_prop_number(vm, obj, val, "year"); + let m = read_prop_number(vm, obj, val, "month"); + let d = read_prop_number(vm, obj, val, "day"); + if y.is_nan() || m.is_nan() || d.is_nan() { + return NativeResult::Err(crate::error::create_type_error(vm, "cannot convert object to PlainDate")); + } + (y.trunc() as i32, m.trunc() as u32, d.trunc() as u32) + } else { + return NativeResult::Err(crate::error::create_type_error(vm, "cannot convert value to PlainDate")); + }; + if !valid_iso_date(year, month, day) { + return NativeResult::Err(crate::error::create_range_error(vm, "invalid ISO date")); + } + make_plain_date(vm, year, month, day) +} + +fn plain_date_ymd(vm: &mut H, args: &[u8]) -> Result<(f64, f64, f64), JsValue> { + let ptr = receiver_obj(vm, args)?; + let obj = unsafe { &*ptr }; + ensure_plain_date(vm, obj)?; + Ok(( + get_double_prop(obj, 0), + get_double_prop(obj, 1), + get_double_prop(obj, 2), + )) +} + +/// `Temporal.PlainDate.prototype.year` getter。 +pub fn plain_date_year(vm: &mut H, args: &[u8]) -> NativeResult { + let (y, _, _) = native_try!(plain_date_ymd(vm, args)); + NativeResult::Ok(JsValue::float(y)) +} + +/// `Temporal.PlainDate.prototype.month` getter。 +pub fn plain_date_month(vm: &mut H, args: &[u8]) -> NativeResult { + let (_, m, _) = native_try!(plain_date_ymd(vm, args)); + NativeResult::Ok(JsValue::float(m)) +} + +/// `Temporal.PlainDate.prototype.day` getter。 +pub fn plain_date_day(vm: &mut H, args: &[u8]) -> NativeResult { + let (_, _, d) = native_try!(plain_date_ymd(vm, args)); + NativeResult::Ok(JsValue::float(d)) +} + +/// `Temporal.PlainDate.prototype.toString()`：输出 `YYYY-MM-DD`。 +pub fn plain_date_to_string(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_plain_date(vm, obj)); + let year = get_double_prop(obj, 0) as i32; + let month = get_double_prop(obj, 1) as u32; + let day = get_double_prop(obj, 2) as u32; + NativeResult::Ok(vm.new_string(&format!("{year:04}-{month:02}-{day:02}"))) +} + +fn make_plain_time(vm: &mut H, hour: u32, minute: u32, second: u32, ms: u32, us: u32, ns: u32) -> NativeResult { + let total_ns = hour as f64 * 3.6e12 + minute as f64 * 6e10 + second as f64 * 1e9 + ms as f64 * 1e6 + us as f64 * 1e3 + ns as f64; + let proto = + JsValue::from_js_object(vm.session().builtin_world().plain_time_proto.as_ptr() as *mut JsObject); + let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, proto); + obj.type_tag = JsObject::OBJ_TYPE_PLAIN_TIME; + obj.set_prop_at(0, JsValue::float(total_ns)); + NativeResult::Ok(JsValue::from_js_object(vm.alloc_object(obj))) +} + +fn valid_plain_time(hour: u32, minute: u32, second: u32, ms: u32, us: u32, ns: u32) -> bool { + hour <= 23 && minute <= 59 && second <= 59 && ms <= 999 && us <= 999 && ns <= 999 +} + +/// `Temporal.PlainTime` 构造器：`new PlainTime(h, m, s, ms, us, ns)`，缺省为 0。 +pub fn plain_time_constructor(vm: &mut H, args: &[u8]) -> NativeResult { + let ctor_proto = vm.session().builtin_world().plain_time_proto.as_ptr(); + if !is_ctor_call(vm, args, ctor_proto) { + return NativeResult::Err(crate::error::create_type_error( + vm, + "Class constructor Temporal.PlainTime cannot be invoked without 'new'", + )); + } + let get = |i: usize, default: f64| -> f64 { + if args.len() > i { + to_number(vm.reg(args[i])).trunc() + } else { + default + } + }; + let hour = get(1, 0.0) as u32; + let minute = get(2, 0.0) as u32; + let second = get(3, 0.0) as u32; + let ms = get(4, 0.0) as u32; + let us = get(5, 0.0) as u32; + let ns = get(6, 0.0) as u32; + if !valid_plain_time(hour, minute, second, ms, us, ns) { + return NativeResult::Err(crate::error::create_range_error(vm, "invalid time component")); + } + make_plain_time(vm, hour, minute, second, ms, us, ns) +} + +/// 拆解午夜后纳秒为各分量。 +fn plain_time_components(total_ns: f64) -> (u32, u32, u32, u32, u32, u32) { + let total = total_ns as u64; + let ns = total % 1_000; + let us = total / 1_000 % 1_000; + let ms = total / 1_000_000 % 1_000; + let second = total / 1_000_000_000 % 60; + let minute = total / 60_000_000_000 % 60; + let hour = total / 3_600_000_000_000 % 24; + (hour as u32, minute as u32, second as u32, ms as u32, us as u32, ns as u32) +} + +fn plain_time_get(vm: &mut H, args: &[u8], select: fn(u32, u32, u32, u32, u32, u32) -> u32) -> NativeResult { + let ptr = match receiver_obj(vm, args) { + Ok(p) => p, + Err(e) => return NativeResult::Err(e), + }; + let obj = unsafe { &*ptr }; + if let Err(e) = ensure_plain_time(vm, obj) { + return NativeResult::Err(e); + } + let (h, m, s, ms, us, ns) = plain_time_components(get_double_prop(obj, 0)); + NativeResult::Ok(JsValue::float(select(h, m, s, ms, us, ns) as f64)) +} + +/// `Temporal.PlainTime.prototype.hour` getter。 +pub fn plain_time_hour(vm: &mut H, args: &[u8]) -> NativeResult { + plain_time_get(vm, args, |h, _, _, _, _, _| h) +} + +/// `Temporal.PlainTime.prototype.minute` getter。 +pub fn plain_time_minute(vm: &mut H, args: &[u8]) -> NativeResult { + plain_time_get(vm, args, |_, m, _, _, _, _| m) +} + +/// `Temporal.PlainTime.prototype.second` getter。 +pub fn plain_time_second(vm: &mut H, args: &[u8]) -> NativeResult { + plain_time_get(vm, args, |_, _, s, _, _, _| s) +} + +/// `Temporal.PlainTime.prototype.millisecond` getter。 +pub fn plain_time_millisecond(vm: &mut H, args: &[u8]) -> NativeResult { + plain_time_get(vm, args, |_, _, _, ms, _, _| ms) +} + +/// `Temporal.PlainTime.prototype.microsecond` getter。 +pub fn plain_time_microsecond(vm: &mut H, args: &[u8]) -> NativeResult { + plain_time_get(vm, args, |_, _, _, _, us, _| us) +} + +/// `Temporal.PlainTime.prototype.nanosecond` getter。 +pub fn plain_time_nanosecond(vm: &mut H, args: &[u8]) -> NativeResult { + plain_time_get(vm, args, |_, _, _, _, _, ns| ns) +} + +/// `Temporal.PlainTime.prototype.toString()`：`HH:MM:SS`，亚秒部分按需输出。 +pub fn plain_time_to_string(vm: &mut H, args: &[u8]) -> NativeResult { + let ptr = native_try!(receiver_obj(vm, args)); + let obj = unsafe { &*ptr }; + native_try!(ensure_plain_time(vm, obj)); + let (h, m, s, ms, us, ns) = plain_time_components(get_double_prop(obj, 0)); + let frac = ms as u64 * 1_000_000 + us as u64 * 1_000 + ns as u64; + if frac == 0 { + NativeResult::Ok(vm.new_string(&format!("{h:02}:{m:02}:{s:02}"))) + } else { + let mut digits = format!("{frac:09}"); + while digits.ends_with('0') { + digits.pop(); + } + NativeResult::Ok(vm.new_string(&format!("{h:02}:{m:02}:{s:02}.{digits}"))) + } +} diff --git a/crates/oxide_kernel/src/builtin.rs b/crates/oxide_kernel/src/builtin.rs index 338a2aa..1365630 100644 --- a/crates/oxide_kernel/src/builtin.rs +++ b/crates/oxide_kernel/src/builtin.rs @@ -243,6 +243,14 @@ pub struct BuiltinWorld { pub sym_has_instance: P, pub sym_match_all: P, pub sym_async_iterator: P, + pub temporal_object: P, + pub temporal_now_object: P, + pub instant_constructor: P, + pub instant_proto: P, + pub plain_date_constructor: P, + pub plain_date_proto: P, + pub plain_time_constructor: P, + pub plain_time_proto: P, pub stub_objects: Vec>, } @@ -491,9 +499,12 @@ fn wire_builtin_world_links(world: &BuiltinWorld) { wire_ctor_proto(&world.float64array_constructor, &world.float64array_proto); wire_ctor_proto(&world.bigint64array_constructor, &world.bigint64array_proto); wire_ctor_proto(&world.biguint64array_constructor, &world.biguint64array_proto); + wire_ctor_proto(&world.instant_constructor, &world.instant_proto); + wire_ctor_proto(&world.plain_date_constructor, &world.plain_date_proto); + wire_ctor_proto(&world.plain_time_constructor, &world.plain_time_proto); let obj_proto_val = JsValue::from_js_object(world.object_proto.as_ptr() as *mut JsObject); - let non_object_protos: [&P; 14] = [ + let non_object_protos: [&P; 17] = [ &world.array_proto, &world.function_proto, &world.string_proto, @@ -508,11 +519,18 @@ fn wire_builtin_world_links(world: &BuiltinWorld) { &world.array_buffer_proto, &world.data_view_proto, &world.typed_array_proto, + &world.instant_proto, + &world.plain_date_proto, + &world.plain_time_proto, ]; for proto in &non_object_protos { set_proto_if_changed(proto, obj_proto_val); } + // Temporal 命名空间对象（非构造器）继承 Object.prototype。 + set_proto_if_changed(&world.temporal_object, obj_proto_val); + set_proto_if_changed(&world.temporal_now_object, obj_proto_val); + let typed_array_proto_val = JsValue::from_js_object(world.typed_array_proto.as_ptr() as *mut JsObject); let typed_array_protos: [&P; 11] = [ &world.int8array_proto, @@ -630,6 +648,14 @@ impl BuiltinWorld { BuiltinId::SymHasInstance => &self.sym_has_instance, BuiltinId::SymMatchAll => &self.sym_match_all, BuiltinId::SymAsyncIterator => &self.sym_async_iterator, + BuiltinId::TemporalObject => &self.temporal_object, + BuiltinId::TemporalNowObject => &self.temporal_now_object, + BuiltinId::InstantConstructor => &self.instant_constructor, + BuiltinId::InstantProto => &self.instant_proto, + BuiltinId::PlainDateConstructor => &self.plain_date_constructor, + BuiltinId::PlainDateProto => &self.plain_date_proto, + BuiltinId::PlainTimeConstructor => &self.plain_time_constructor, + BuiltinId::PlainTimeProto => &self.plain_time_proto, } } @@ -671,6 +697,13 @@ impl BuiltinWorld { let sym_has_instance = P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())); let sym_match_all = P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())); let sym_async_iterator = P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())); + let temporal_object = P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())); + let temporal_now_object = P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())); + let (instant_proto, instant_constructor) = make_named_pair(string_forge, shape_forge, labels, "Instant"); + let (plain_date_proto, plain_date_constructor) = + make_named_pair(string_forge, shape_forge, labels, "PlainDate"); + let (plain_time_proto, plain_time_constructor) = + make_named_pair(string_forge, shape_forge, labels, "PlainTime"); let stub_objects = Vec::new(); let world = Self { @@ -743,6 +776,14 @@ impl BuiltinWorld { sym_has_instance, sym_match_all, sym_async_iterator, + temporal_object, + temporal_now_object, + instant_constructor, + instant_proto, + plain_date_constructor, + plain_date_proto, + plain_time_constructor, + plain_time_proto, stub_objects, }; wire_builtin_world_links(&world); @@ -917,6 +958,35 @@ impl BuiltinWorld { biguint64array_proto: current.biguint64array_proto.clone(), } }; + let (temporal_object, temporal_now_object, instant_proto, instant_constructor, plain_date_proto, plain_date_constructor, plain_time_proto, plain_time_constructor) = if dirty.temporal { + let (instant_proto, instant_constructor) = + make_named_pair(string_forge, shape_forge, labels, "Instant"); + let (plain_date_proto, plain_date_constructor) = + make_named_pair(string_forge, shape_forge, labels, "PlainDate"); + let (plain_time_proto, plain_time_constructor) = + make_named_pair(string_forge, shape_forge, labels, "PlainTime"); + ( + P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())), + P::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null())), + instant_proto, + instant_constructor, + plain_date_proto, + plain_date_constructor, + plain_time_proto, + plain_time_constructor, + ) + } else { + ( + current.temporal_object.clone(), + current.temporal_now_object.clone(), + current.instant_proto.clone(), + current.instant_constructor.clone(), + current.plain_date_proto.clone(), + current.plain_date_constructor.clone(), + current.plain_time_proto.clone(), + current.plain_time_constructor.clone(), + ) + }; let stub_objects = if dirty.stubs { Vec::new() } else { current.stub_objects.clone() }; let world = BuiltinWorld { @@ -989,6 +1059,14 @@ impl BuiltinWorld { sym_has_instance, sym_match_all, sym_async_iterator, + temporal_object, + temporal_now_object, + instant_constructor, + instant_proto, + plain_date_constructor, + plain_date_proto, + plain_time_constructor, + plain_time_proto, stub_objects, }; wire_builtin_world_links(&world); diff --git a/crates/oxide_kernel/src/kernel.rs b/crates/oxide_kernel/src/kernel.rs index a38f699..49391f5 100644 --- a/crates/oxide_kernel/src/kernel.rs +++ b/crates/oxide_kernel/src/kernel.rs @@ -225,7 +225,7 @@ pub struct KernelSession { /// 维护注意：每个新增的 `BuiltinWorld` 对象字段都必须加到这里以及 /// `KernelSession::dirty_since_snapshot()`，以便选择性重置重建正确的 /// builtin 家族。 -pub const NUM_BUILTINS: usize = 68; +pub const NUM_BUILTINS: usize = 76; /// 内置对象枚举 id，与 `BuiltinWorld` 中的存储槽一一对应。 /// @@ -302,6 +302,14 @@ pub enum BuiltinId { SymHasInstance = 65, SymMatchAll = 66, SymAsyncIterator = 67, + TemporalObject = 68, + TemporalNowObject = 69, + InstantConstructor = 70, + InstantProto = 71, + PlainDateConstructor = 72, + PlainDateProto = 73, + PlainTimeConstructor = 74, + PlainTimeProto = 75, } impl BuiltinId { @@ -375,6 +383,14 @@ impl BuiltinId { BuiltinId::SymHasInstance, BuiltinId::SymMatchAll, BuiltinId::SymAsyncIterator, + BuiltinId::TemporalObject, + BuiltinId::TemporalNowObject, + BuiltinId::InstantConstructor, + BuiltinId::InstantProto, + BuiltinId::PlainDateConstructor, + BuiltinId::PlainDateProto, + BuiltinId::PlainTimeConstructor, + BuiltinId::PlainTimeProto, ]; } @@ -432,6 +448,7 @@ pub struct BuiltinDirtySet { pub array_buffer: bool, pub data_view: bool, pub typed_array_family: bool, + pub temporal: bool, pub stubs: bool, pub global: bool, } @@ -456,6 +473,7 @@ impl BuiltinDirtySet { || self.array_buffer || self.data_view || self.typed_array_family + || self.temporal || self.stubs } @@ -598,6 +616,14 @@ impl KernelSession { || gen(BuiltinId::BigInt64ArrayProto) != snap(BuiltinId::BigInt64ArrayProto) || gen(BuiltinId::BigUint64ArrayConstructor) != snap(BuiltinId::BigUint64ArrayConstructor) || gen(BuiltinId::BigUint64ArrayProto) != snap(BuiltinId::BigUint64ArrayProto), + temporal: gen(BuiltinId::TemporalObject) != snap(BuiltinId::TemporalObject) + || gen(BuiltinId::TemporalNowObject) != snap(BuiltinId::TemporalNowObject) + || gen(BuiltinId::InstantConstructor) != snap(BuiltinId::InstantConstructor) + || gen(BuiltinId::InstantProto) != snap(BuiltinId::InstantProto) + || gen(BuiltinId::PlainDateConstructor) != snap(BuiltinId::PlainDateConstructor) + || gen(BuiltinId::PlainDateProto) != snap(BuiltinId::PlainDateProto) + || gen(BuiltinId::PlainTimeConstructor) != snap(BuiltinId::PlainTimeConstructor) + || gen(BuiltinId::PlainTimeProto) != snap(BuiltinId::PlainTimeProto), stubs: world.stub_objects.len() != snapshot.stub_objects_len || stub_generations_dirty, global: BuiltinSnapshot::gen(&self.global_object) != snapshot.global_object_generation, } diff --git a/crates/oxide_types/src/object.rs b/crates/oxide_types/src/object.rs index 4c26bd7..baebaf8 100644 --- a/crates/oxide_types/src/object.rs +++ b/crates/oxide_types/src/object.rs @@ -437,6 +437,12 @@ impl JsObject { /// 异步生成器迭代器对象（`async function*` 调用返回）：`AsyncGeneratorState` /// 快照存于 `native_data`。 pub const OBJ_TYPE_ASYNC_GENERATOR: u8 = 13; + /// Temporal.Instant 对象：纪元纳秒存于 prop 0。 + pub const OBJ_TYPE_INSTANT: u8 = 14; + /// Temporal.PlainDate 对象：ISO 年/月/日存于 prop 0-2。 + pub const OBJ_TYPE_PLAIN_DATE: u8 = 15; + /// Temporal.PlainTime 对象：午夜后纳秒存于 prop 0。 + pub const OBJ_TYPE_PLAIN_TIME: u8 = 16; /// `is_session_epoch` 字段中的 session 标记位。 pub const SESSION_EPOCH_BIT: u8 = 0x01; /// `is_session_epoch` 字段中的 GC 标记位。 @@ -502,6 +508,21 @@ impl JsObject { pub fn is_async_generator_obj(&self) -> bool { self.type_tag == Self::OBJ_TYPE_ASYNC_GENERATOR } + /// 是否 Temporal.Instant 对象。 + #[inline] + pub fn is_instant_obj(&self) -> bool { + self.type_tag == Self::OBJ_TYPE_INSTANT + } + /// 是否 Temporal.PlainDate 对象。 + #[inline] + pub fn is_plain_date_obj(&self) -> bool { + self.type_tag == Self::OBJ_TYPE_PLAIN_DATE + } + /// 是否 Temporal.PlainTime 对象。 + #[inline] + pub fn is_plain_time_obj(&self) -> bool { + self.type_tag == Self::OBJ_TYPE_PLAIN_TIME + } /// 构造无属性、可扩展的空对象（`new Object()` 的基础对象）。 pub fn new_empty(shape_id: ShapeId, proto: JsValue) -> Self { diff --git a/crates/oxide_vm/src/bindings/bind_temporal.rs b/crates/oxide_vm/src/bindings/bind_temporal.rs new file mode 100644 index 0000000..084966d --- /dev/null +++ b/crates/oxide_vm/src/bindings/bind_temporal.rs @@ -0,0 +1,194 @@ +use std::sync::Arc; + +use crate::bindings::{apply_binding_table, bind_accessor_getter, bind_global_value, configure_native_constructor}; +use oxide_kernel::kernel::{KernelCore, KernelSession}; +use oxide_types::object::JsObject; +use oxide_types::value::JsValue; + +/// 把 Temporal 命名空间及其 Now/Instant/PlainDate/PlainTime 子对象绑定到 global。 +pub fn bind_temporal(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let world = session.builtin_world(); + let temporal_ptr = world.temporal_object.as_ptr() as *mut JsObject; + let temporal = unsafe { &mut *temporal_ptr }; + + // Temporal.Now：非构造器命名空间，方法直接绑定。 + let now_ptr = world.temporal_now_object.as_ptr() as *mut JsObject; + let now = unsafe { &mut *now_ptr }; + apply_binding_table( + world, + now, + core, + &[ + ("instant", oxide_builtins::temporal::now_instant:: as *const (), 0), + ( + "timeZoneId", + oxide_builtins::temporal::now_time_zone_id:: as *const (), + 0, + ), + ], + ); + + // Temporal.Instant：构造器 + from 静态方法 + 原型 getter 与 toString/valueOf。 + let instant_ctor_ptr = world.instant_constructor.as_ptr() as *mut JsObject; + let instant_ctor = unsafe { &mut *instant_ctor_ptr }; + configure_native_constructor( + instant_ctor, + oxide_builtins::temporal::instant_constructor:: as *const (), + 1, + ); + apply_binding_table( + world, + instant_ctor, + core, + &[("from", oxide_builtins::temporal::instant_from:: as *const (), 1)], + ); + let instant_proto_ptr = world.instant_proto.as_ptr() as *mut JsObject; + let instant_proto = unsafe { &mut *instant_proto_ptr }; + bind_accessor_getter( + core, + session, + instant_proto, + "epochSeconds", + oxide_builtins::temporal::instant_epoch_seconds:: as *const (), + ); + bind_accessor_getter( + core, + session, + instant_proto, + "epochMilliseconds", + oxide_builtins::temporal::instant_epoch_milliseconds:: as *const (), + ); + bind_accessor_getter( + core, + session, + instant_proto, + "epochMicroseconds", + oxide_builtins::temporal::instant_epoch_microseconds:: as *const (), + ); + bind_accessor_getter( + core, + session, + instant_proto, + "epochNanoseconds", + oxide_builtins::temporal::instant_epoch_nanoseconds:: as *const (), + ); + apply_binding_table( + world, + instant_proto, + core, + &[ + ("toString", oxide_builtins::temporal::instant_to_string:: as *const (), 0), + ("valueOf", oxide_builtins::temporal::instant_value_of:: as *const (), 0), + ], + ); + + // Temporal.PlainDate：构造器 + from 静态方法 + year/month/day getter 与 toString。 + let plain_date_ctor_ptr = world.plain_date_constructor.as_ptr() as *mut JsObject; + let plain_date_ctor = unsafe { &mut *plain_date_ctor_ptr }; + configure_native_constructor( + plain_date_ctor, + oxide_builtins::temporal::plain_date_constructor:: as *const (), + 3, + ); + apply_binding_table( + world, + plain_date_ctor, + core, + &[("from", oxide_builtins::temporal::plain_date_from:: as *const (), 1)], + ); + let plain_date_proto_ptr = world.plain_date_proto.as_ptr() as *mut JsObject; + let plain_date_proto = unsafe { &mut *plain_date_proto_ptr }; + bind_accessor_getter( + core, + session, + plain_date_proto, + "year", + oxide_builtins::temporal::plain_date_year:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_date_proto, + "month", + oxide_builtins::temporal::plain_date_month:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_date_proto, + "day", + oxide_builtins::temporal::plain_date_day:: as *const (), + ); + apply_binding_table( + world, + plain_date_proto, + core, + &[("toString", oxide_builtins::temporal::plain_date_to_string:: as *const (), 0)], + ); + + // Temporal.PlainTime：构造器 + 6 个分量 getter 与 toString。 + let plain_time_ctor_ptr = world.plain_time_constructor.as_ptr() as *mut JsObject; + let plain_time_ctor = unsafe { &mut *plain_time_ctor_ptr }; + configure_native_constructor( + plain_time_ctor, + oxide_builtins::temporal::plain_time_constructor:: as *const (), + 6, + ); + let plain_time_proto_ptr = world.plain_time_proto.as_ptr() as *mut JsObject; + let plain_time_proto = unsafe { &mut *plain_time_proto_ptr }; + bind_accessor_getter( + core, + session, + plain_time_proto, + "hour", + oxide_builtins::temporal::plain_time_hour:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_time_proto, + "minute", + oxide_builtins::temporal::plain_time_minute:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_time_proto, + "second", + oxide_builtins::temporal::plain_time_second:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_time_proto, + "millisecond", + oxide_builtins::temporal::plain_time_millisecond:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_time_proto, + "microsecond", + oxide_builtins::temporal::plain_time_microsecond:: as *const (), + ); + bind_accessor_getter( + core, + session, + plain_time_proto, + "nanosecond", + oxide_builtins::temporal::plain_time_nanosecond:: as *const (), + ); + apply_binding_table( + world, + plain_time_proto, + core, + &[("toString", oxide_builtins::temporal::plain_time_to_string:: as *const (), 0)], + ); + + // 把子对象挂到 Temporal 命名空间对象上，再把 Temporal 挂到 global。 + bind_global_value(core, temporal, "Now", JsValue::from_js_object(now_ptr)); + bind_global_value(core, temporal, "Instant", JsValue::from_js_object(instant_ctor_ptr)); + bind_global_value(core, temporal, "PlainDate", JsValue::from_js_object(plain_date_ctor_ptr)); + bind_global_value(core, temporal, "PlainTime", JsValue::from_js_object(plain_time_ctor_ptr)); + bind_global_value(core, global, "Temporal", JsValue::from_js_object(temporal_ptr)); +} diff --git a/crates/oxide_vm/src/bindings/mod.rs b/crates/oxide_vm/src/bindings/mod.rs index 2eb3601..c2a9dc8 100644 --- a/crates/oxide_vm/src/bindings/mod.rs +++ b/crates/oxide_vm/src/bindings/mod.rs @@ -42,6 +42,8 @@ pub mod bind_string; pub mod bind_stubs; /// Symbol 构造器与原型的 native 方法绑定。 pub mod bind_symbol; +/// Temporal 命名空间对象（Now/Instant/PlainDate/PlainTime）绑定。 +pub mod bind_temporal; /// 各 TypedArray 构造器与共享原型的 native 方法绑定。 pub mod bind_typed_array; @@ -483,6 +485,7 @@ pub fn bind_global_builtin_slots(core: &Arc, session: &KernelSession ("Symbol", JsValue::from_js_object(world.symbol_constructor.as_ptr() as *mut JsObject)), ("Math", JsValue::from_js_object(world.math_object.as_ptr() as *mut JsObject)), ("JSON", JsValue::from_js_object(world.json_object.as_ptr() as *mut JsObject)), + ("Temporal", JsValue::from_js_object(world.temporal_object.as_ptr() as *mut JsObject)), ] { bind_existing_global(core, global, name, value); } @@ -665,6 +668,9 @@ pub fn rebind_dirty_builtins(core: &Arc, session: &mut KernelSession if dirty.map_or(true, |d| d.symbol_family) { bind_symbol::bind_symbol(core, session, global); } + if dirty.map_or(true, |d| d.temporal) { + bind_temporal::bind_temporal(core, session, global); + } if dirty.map_or(true, |d| d.stubs) { bind_stubs::bind_stubs(core, session, global); } diff --git a/crates/oxide_vm/tests/builtins_temporal_tests.rs b/crates/oxide_vm/tests/builtins_temporal_tests.rs new file mode 100644 index 0000000..eab9de2 --- /dev/null +++ b/crates/oxide_vm/tests/builtins_temporal_tests.rs @@ -0,0 +1,242 @@ +use oxide_compiler::compiler::Compiler; +use oxide_vm::vm::Vm; + +fn eval(vm: &mut Vm, source: &str) -> Result { + let allocator = oxide_parser::Allocator::default(); + let program = oxide_parser::parse(&allocator, source).map_err(|e| format!("Parse error: {:?}", e))?; + let module = Compiler::new().compile(&program).map_err(|e| format!("Compile error: {}", e))?; + vm.run(&module) +} + +fn str_val(vm: &Vm, val: oxide_types::value::JsValue) -> String { + vm.lookup_str(val).unwrap_or_default() +} + +fn num(vm: &mut Vm, source: &str) -> f64 { + let r = eval(vm, source).unwrap(); + if r.is_double() { + r.as_double() + } else { + r.as_int() as f64 + } +} + +// -- Temporal 命名空间 -- + +#[test] +fn temporal_is_object() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "typeof Temporal").unwrap(); + assert_eq!(str_val(&vm, r), "object"); +} + +#[test] +fn temporal_now_time_zone_id_is_utc() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Temporal.Now.timeZoneId()").unwrap(); + assert_eq!(str_val(&vm, r), "UTC"); +} + +#[test] +fn temporal_now_instant_returns_instant() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Temporal.Now.instant() instanceof Temporal.Instant").unwrap(); + assert!(r.as_bool()); +} + +#[test] +fn temporal_now_instant_epoch_is_positive() { + let mut vm = Vm::new(); + let r = num(&mut vm, "Temporal.Now.instant().epochMilliseconds"); + assert!(r > 1_500_000_000_000.0); +} + +#[test] +fn temporal_now_is_namespace_not_constructor() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "typeof Temporal.Now").unwrap(); + assert_eq!(str_val(&vm, r), "object"); +} + +// -- Temporal.Instant -- + +#[test] +fn instant_from_iso_string() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Temporal.Instant.from('2024-01-01T00:00:00Z').toString()").unwrap(); + assert_eq!(str_val(&vm, r), "2024-01-01T00:00:00Z"); +} + +#[test] +fn instant_epoch_seconds() { + let mut vm = Vm::new(); + assert_eq!(num(&mut vm, "Temporal.Instant.from('2024-01-01T00:00:00Z').epochSeconds"), 1704067200.0); +} + +#[test] +fn instant_epoch_milliseconds() { + let mut vm = Vm::new(); + assert_eq!( + num(&mut vm, "Temporal.Instant.from('2024-01-01T00:00:00Z').epochMilliseconds"), + 1704067200000.0 + ); +} + +#[test] +fn instant_epoch_nanoseconds() { + let mut vm = Vm::new(); + assert_eq!( + num(&mut vm, "Temporal.Instant.from('2024-01-01T00:00:00Z').epochNanoseconds"), + 1704067200000000000.0 + ); +} + +#[test] +fn instant_constructor_requires_new() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { Temporal.Instant(0); 'no' } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "TypeError"); +} + +#[test] +fn instant_value_of_throws() { + let mut vm = Vm::new(); + let r = eval( + &mut vm, + "try { Temporal.Instant.prototype.valueOf.call(Temporal.Now.instant()) } catch (e) { e.constructor.name }", + ) + .unwrap(); + assert_eq!(str_val(&vm, r), "TypeError"); +} + +#[test] +fn instant_method_on_non_instant_throws() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { Temporal.Instant.prototype.toString.call({}) } catch (e) { e.constructor.name }") + .unwrap(); + assert_eq!(str_val(&vm, r), "TypeError"); +} + +#[test] +fn instant_from_invalid_throws_range_error() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { Temporal.Instant.from('nope') } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "RangeError"); +} + +// -- Temporal.PlainDate -- + +#[test] +fn plain_date_from_string() { + let mut vm = Vm::new(); + assert_eq!(num(&mut vm, "Temporal.PlainDate.from('2024-01-15').year"), 2024.0); + assert_eq!(num(&mut vm, "Temporal.PlainDate.from('2024-01-15').month"), 1.0); + assert_eq!(num(&mut vm, "Temporal.PlainDate.from('2024-01-15').day"), 15.0); +} + +#[test] +fn plain_date_from_object() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Temporal.PlainDate.from({year:2023, month:3, day:5}).toString()").unwrap(); + assert_eq!(str_val(&vm, r), "2023-03-05"); +} + +#[test] +fn plain_date_constructor_month_day() { + let mut vm = Vm::new(); + assert_eq!(num(&mut vm, "new Temporal.PlainDate(2024, 2, 29).month"), 2.0); + assert_eq!(num(&mut vm, "new Temporal.PlainDate(2024, 2, 29).day"), 29.0); + assert_eq!(num(&mut vm, "new Temporal.PlainDate(2024, 2, 29).year"), 2024.0); +} + +#[test] +fn plain_date_leap_year_validation() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { new Temporal.PlainDate(2024, 2, 30) } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "RangeError"); +} + +#[test] +fn plain_date_invalid_month() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { new Temporal.PlainDate(2024, 13, 1) } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "RangeError"); +} + +#[test] +fn plain_date_to_string() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Temporal.PlainDate(2024, 1, 5).toString()").unwrap(); + assert_eq!(str_val(&vm, r), "2024-01-05"); +} + +#[test] +fn plain_date_requires_new() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { Temporal.PlainDate(2024, 1, 1); 'no' } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "TypeError"); +} + +#[test] +fn plain_date_method_on_non_date_throws() { + let mut vm = Vm::new(); + let r = eval( + &mut vm, + "try { Temporal.PlainDate.prototype.year.get.call({}) } catch (e) { e.constructor.name }", + ) + .unwrap(); + assert_eq!(str_val(&vm, r), "TypeError"); +} + +// -- Temporal.PlainTime -- + +#[test] +fn plain_time_constructor_components() { + let mut vm = Vm::new(); + assert_eq!(num(&mut vm, "new Temporal.PlainTime(12, 30, 5).hour"), 12.0); + assert_eq!(num(&mut vm, "new Temporal.PlainTime(12, 30, 5).minute"), 30.0); + assert_eq!(num(&mut vm, "new Temporal.PlainTime(12, 30, 5).second"), 5.0); +} + +#[test] +fn plain_time_full_precision_components() { + let mut vm = Vm::new(); + let r = eval( + &mut vm, + "let t = new Temporal.PlainTime(23, 59, 59, 999, 999, 999); t.hour + ',' + t.minute + ',' + t.second + ',' + t.millisecond + ',' + t.microsecond + ',' + t.nanosecond", + ) + .unwrap(); + assert_eq!(str_val(&vm, r), "23,59,59,999,999,999"); +} + +#[test] +fn plain_time_to_string() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Temporal.PlainTime(12, 30, 5).toString()").unwrap(); + assert_eq!(str_val(&vm, r), "12:30:05"); +} + +#[test] +fn plain_time_to_string_with_subseconds() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Temporal.PlainTime(12, 30, 5, 500, 250, 1).toString()").unwrap(); + assert_eq!(str_val(&vm, r), "12:30:05.500250001"); +} + +#[test] +fn plain_time_missing_components_default_zero() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Temporal.PlainTime().toString()").unwrap(); + assert_eq!(str_val(&vm, r), "00:00:00"); + let r = eval(&mut vm, "new Temporal.PlainTime(12).toString()").unwrap(); + assert_eq!(str_val(&vm, r), "12:00:00"); +} + +#[test] +fn plain_time_range_validation() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "try { new Temporal.PlainTime(24, 0, 0) } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "RangeError"); + let r = eval(&mut vm, "try { new Temporal.PlainTime(0, 60, 0) } catch (e) { e.constructor.name }").unwrap(); + assert_eq!(str_val(&vm, r), "RangeError"); +}