Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

feat(webidl): derive wrapping signed long long conversion

ldm08ca9986eec1f
diff --git a/moli-webidl-derive/src/converter.rs b/moli-webidl-derive/src/converter.rs
index f2ec9999d..2f926bbb2 100644
--- a/moli-webidl-derive/src/converter.rs
+++ b/moli-webidl-derive/src/converter.rs
@@ -14,6 +14,7 @@ pub(crate) enum ConverterKind {
CallbackFunction,
CallbackInterface,
Long,
+ LongLong,
EnforceRangeLong,
Short,
UnsignedShort,
@@ -49,6 +50,7 @@ impl ConverterKind {
"callback_function" => Ok(Self::CallbackFunction),
"callback_interface" => Ok(Self::CallbackInterface),
"long" => Ok(Self::Long),
+ "long_long" => Ok(Self::LongLong),
"enforce_range_long" => Ok(Self::EnforceRangeLong),
"short" => Ok(Self::Short),
"unsigned_short" => Ok(Self::UnsignedShort),
@@ -81,6 +83,7 @@ impl ConverterKind {
Self::CallbackFunction => quote!(::moli_webidl::WebIdlCallbackFunction),
Self::CallbackInterface => quote!(::moli_webidl::WebIdlCallbackInterface),
Self::Long => quote!(::moli_webidl::Long),
+ Self::LongLong => quote!(::moli_webidl::LongLong),
Self::EnforceRangeLong => quote!(::moli_webidl::EnforceRangeLong),
Self::Short => quote!(::moli_webidl::Short),
Self::UnsignedShort => quote!(::moli_webidl::UnsignedShort),
@@ -122,6 +125,7 @@ impl ConverterKind {
Self::BufferSource => quote!(::moli_webidl::BufferSource::from(#expr)),
Self::CallbackFunction | Self::CallbackInterface => quote!(#expr),
Self::Long => quote!(::moli_webidl::Long(#expr)),
+ Self::LongLong => quote!(::moli_webidl::LongLong(#expr)),
Self::EnforceRangeLong => quote!(::moli_webidl::EnforceRangeLong(#expr)),
Self::Short => quote!(::moli_webidl::Short(#expr)),
Self::UnsignedShort => quote!(::moli_webidl::UnsignedShort(#expr)),
@@ -158,6 +162,7 @@ impl ConverterKind {
Self::DomString
| Self::UsvString
| Self::Long
+ | Self::LongLong
| Self::EnforceRangeLong
| Self::Short
| Self::UnsignedShort
@@ -372,6 +377,9 @@ fn infer_converter_kind(ty: &Type) -> Option<ConverterKind> {
if is_type_ident(ty, "i16") {
return Some(ConverterKind::Short);
}
+ if is_type_ident(ty, "i64") {
+ return Some(ConverterKind::LongLong);
+ }
if is_type_ident(ty, "u64") {
return Some(ConverterKind::UnsignedLongLong);
}
diff --git a/moli-webidl/src/convert.rs b/moli-webidl/src/convert.rs
index 75f806846..0d94186df 100644
--- a/moli-webidl/src/convert.rs
+++ b/moli-webidl/src/convert.rs
@@ -331,6 +331,19 @@ impl<'s> WebIdlConverter<'s> for UnsignedLongLong {
}
}
+impl<'s> WebIdlConverter<'s> for crate::LongLong {
+ type Options = ();
+ fn convert(
+ scope: &mut v8::PinScope<'s, '_>,
+ value: v8::Local<'s, v8::Value>,
+ context: Context,
+ _: &(),
+ ) -> Result<Self, WebIdlError> {
+ number_value(scope, value, context, "long long")
+ .map(|value| Self(unsigned_long_long(value) as i64))
+ }
+}
+
impl<'s> WebIdlConverter<'s> for EnforceRangeLongLong {
type Options = ();
diff --git a/moli-webidl/src/lib.rs b/moli-webidl/src/lib.rs
index 32648cb46..2e03bee00 100644
--- a/moli-webidl/src/lib.rs
+++ b/moli-webidl/src/lib.rs
@@ -95,8 +95,8 @@ pub use traits::{ParseOutcome, WebIdlArguments, WebIdlConverter, WebIdlDictionar
pub use types::{
Boolean, BufferSource, ByteString, ClampedUnsignedShort, Dictionary, DomString, DomString16,
Double, EnforceRangeLong, EnforceRangeUnsignedLong, EnforceRangeUnsignedLongLong, EnumValue,
- EventListenerOptions, InterfaceObject, InterfaceOptions, Long, Record, Sequence, Short,
- StringOptions, UnrestrictedDouble, UnrestrictedFloat, UnsignedLong, UnsignedLongLong,
+ EventListenerOptions, InterfaceObject, InterfaceOptions, Long, LongLong, Record, Sequence,
+ Short, StringOptions, UnrestrictedDouble, UnrestrictedFloat, UnsignedLong, UnsignedLongLong,
UnsignedShort, UsvString,
};
diff --git a/moli-webidl/src/types.rs b/moli-webidl/src/types.rs
index c5be05eaf..fd4a9af9e 100644
--- a/moli-webidl/src/types.rs
+++ b/moli-webidl/src/types.rs
@@ -298,6 +298,15 @@ impl From<ClampedUnsignedShort> for u16 {
}
}
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct LongLong(pub i64);
+
+impl From<LongLong> for i64 {
+ fn from(value: LongLong) -> Self {
+ value.0
+ }
+}
+
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct UnsignedLongLong(pub u64);
diff --git a/moli-webidl/tests/long_long.rs b/moli-webidl/tests/long_long.rs
new file mode 100644
index 000000000..ccca9777f
--- /dev/null
+++ b/moli-webidl/tests/long_long.rs
@@ -0,0 +1,60 @@
+use moli_webidl::{Context, WebIdlDictionary};
+
+#[derive(WebIdlDictionary)]
+#[webidl(prefix = "LongLongInit")]
+struct Init {
+ #[webidl(default = 0)]
+ value: i64,
+ #[webidl(converter = "long_long", default = 0)]
+ explicit: i64,
+}
+
+#[test]
+fn long_long_derive_wraps_and_preserves_conversion_errors() {
+ moli_v8_test_util::ensure_v8();
+ let mut isolate = v8::Isolate::new(v8::CreateParams::default());
+ v8::scope!(let scope, &mut isolate);
+ let context = v8::Context::new(scope, Default::default());
+ let scope = &mut v8::ContextScope::new(scope, context);
+ for (expression, expected) in [
+ ("-17.9", -17),
+ ("NaN", 0),
+ ("Infinity", 0),
+ ("undefined", 0),
+ ("2**63", i64::MIN),
+ ("2**64", 0),
+ ("-(2**63)-2048", i64::MAX - 2047),
+ ] {
+ let source = v8::String::new(
+ scope,
+ &format!("({{value:{expression},explicit:{expression}}})"),
+ )
+ .unwrap();
+ let value = v8::Script::compile(scope, source, None)
+ .unwrap()
+ .run(scope)
+ .unwrap();
+ let init =
+ moli_webidl::parse_dictionary::<Init>(scope, value, Context::argument("Test", 1))
+ .unwrap()
+ .unwrap();
+ assert_eq!(init.value, expected, "{expression}");
+ assert_eq!(init.explicit, expected, "{expression}");
+ }
+ for source in [
+ "({value:Symbol(),explicit:0})",
+ "({value:0,explicit:1n})",
+ "({get explicit(){throw 42},value:0})",
+ ] {
+ v8::tc_scope!(let scope, scope);
+ let source = v8::String::new(scope, source).unwrap();
+ let value = v8::Script::compile(scope, source, None)
+ .unwrap()
+ .run(scope)
+ .unwrap();
+ assert!(
+ moli_webidl::parse_dictionary::<Init>(scope, value, Context::argument("Test", 1))
+ .is_err()
+ );
+ }
+}