Define QuotaExceededError and Buffer as native subclasses instead of eval

Replaces the manual QuotaExceededError class and the eval'd Buffer class
with a shared define_subclass helper that wires both prototype links the
way class-extends does, so static members like Buffer.of are inherited.

Author: richarddd

libs/llrt_utils/src/object.rs

@@ -3,8 +3,12 @@
 use std::collections::BTreeMap;
 
 use rquickjs::{
-    atom::PredefinedAtom, function::IntoJsFunc, prelude::Func, Array, Coerced, Ctx, Error,
-    Exception, FromJs, IntoAtom, IntoJs, Object, Result, Undefined, Value,
+    atom::PredefinedAtom,
+    function::{Constructor, IntoJsFunc},
+    object::Property,
+    prelude::Func,
+    Array, Coerced, Ctx, Error, Exception, FromJs, IntoAtom, IntoJs, Object, Result, Undefined,
+    Value,
 };
 
 use crate::primordials::{BasePrimordials, Primordial};
@@ -145,3 +149,22 @@ pub fn object_from_entries<'js>(ctx: &Ctx<'js>, array: Array<'js>) -> Result<Obj
     }
     Ok(obj)
 }
+
+/// Build a constructor that behaves like `class Name extends Parent`
+pub fn define_subclass<'js, F, P>(
+    ctx: &Ctx<'js>,
+    name: &str,
+    parent: &Constructor<'js>,
+    construct: F,
+) -> Result<Constructor<'js>>
+where
+    F: IntoJsFunc<'js, P> + 'js,
+{
+    let parent_proto: Object = parent.get(PredefinedAtom::Prototype)?;
+    let proto = Object::new(ctx.clone())?;
+    proto.set_prototype(Some(&parent_proto))?;
+    let constructor = Constructor::new_prototype(ctx, proto, construct)?;
+    constructor.set_prototype(parent.as_object())?;
+    constructor.prop(PredefinedAtom::Name, Property::from(name).configurable())?;
+    Ok(constructor)
+}

modules/llrt_buffer/src/lib.rs

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 use llrt_utils::{
     module::{export_default, ModuleInfo},
+    object::define_subclass,
     primordials::{BasePrimordials, Primordial},
 };
 use rquickjs::{
-    function::Constructor,
+    function::{Args, Constructor, Rest},
     module::{Declarations, Exports, ModuleDef},
-    Class, Ctx, Function, IntoJs, Object, Result,
+    Class, Ctx, Function, IntoJs, Object, Result, Value,
 };
 
 pub use self::array_buffer_view::*;
@@ -68,13 +69,21 @@ pub fn init<'js>(ctx: &Ctx<'js>) -> Result<()> {
     let globals = ctx.globals();
     BasePrimordials::init(ctx)?;
 
-    // Buffer
-    let buffer = ctx.eval::<Object<'js>, &str>(concat!(
-        "class ",
+    // Buffer extends the native Uint8Array: it forwards construction to the
+    // Uint8Array constructor and inherits its static and prototype members.
+    let uint8array = BasePrimordials::get(ctx)?.constructor_uint8array.clone();
+    let buffer_ctor = define_subclass(
+        ctx,
         stringify!(Buffer),
-        " extends Uint8Array {}\n",
-        stringify!(Buffer),
-    ))?;
+        &uint8array,
+        |ctx: Ctx<'js>, args: Rest<Value<'js>>| {
+            let uint8array = &BasePrimordials::get(&ctx)?.constructor_uint8array;
+            let mut ctor_args = Args::new(ctx.clone(), args.0.len());
+            ctor_args.push_args(args.0)?;
+            ctor_args.construct::<Value>(uint8array)
+        },
+    )?;
+    let buffer: Object = buffer_ctor.into_value().into_object().unwrap();
     set_prototype(ctx, buffer)?;
 
     BufferPrimordials::init(ctx)?;

modules/llrt_crypto/src/lib.rs

@@ -31,7 +31,7 @@ use std::slice;
 use llrt_buffer::Buffer;
 use llrt_context::CtxExtension;
 use llrt_encoding::{bytes_to_b64_string, bytes_to_hex_string};
-use llrt_exceptions::{DOMException, QuotaExceededError};
+use llrt_exceptions::DOMException;
 use llrt_utils::{
     bytes::{get_start_end_indexes, ObjectBytes},
     error::ErrorExtensions,
@@ -183,7 +183,7 @@ fn get_random_values<'js>(ctx: Ctx<'js>, obj: Object<'js>) -> Result<Object<'js>
             .or_throw(&ctx)?;
 
         if source_length > 0x10000 {
-            return Err(QuotaExceededError::quota_exceeded_error(
+            return Err(DOMException::quota_exceeded_error(
                 &ctx,
                 "The requested length exceeds 65,536 bytes",
             ));

modules/llrt_exceptions/src/lib.rs

@@ -1,11 +1,10 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-mod quota_exceeded_error;
-
 use core::fmt;
 use std::fmt::Debug;
 
 use llrt_utils::{
+    object::define_subclass,
     option::Undefined,
     primordials::{BasePrimordials, Primordial},
 };
@@ -21,7 +20,6 @@ use rquickjs::{
     qjs, Class, Coerced, Ctx, Error, Exception, FromJs, IntoJs, JsLifetime, Object, Result, Value,
 };
 
-pub use crate::quota_exceeded_error::QuotaExceededError;
 use crate::DOMExceptionName::{NotSupportedError, OperationError, TypeMismatchError};
 
 #[derive(Trace, JsLifetime, Debug)]
@@ -228,6 +226,46 @@ impl<'js> DOMException {
     pub fn operation_error(ctx: &Ctx<'js>, message: impl Into<String>) -> Error {
         Self::create_error(ctx, OperationError, message)
     }
+
+    pub fn quota_exceeded_error(ctx: &Ctx<'js>, message: impl Into<String>) -> Error {
+        let value = Self::create_quota_exceeded(ctx, message.into())
+            .expect("failed to create QuotaExceededError");
+        Self::throw_value(ctx, value)
+    }
+
+    fn create_quota_exceeded(ctx: &Ctx<'js>, message: String) -> Result<Value<'js>> {
+        let ctor: Constructor = ctx.globals().get("QuotaExceededError")?;
+        ctor.construct((message,))
+    }
+
+    fn define_quota_exceeded_error(ctx: &Ctx<'js>) -> Result<()> {
+        let dom_exception: Constructor = ctx.globals().get(DOMException::NAME)?;
+        let quota_exceeded_error = define_subclass(
+            ctx,
+            "QuotaExceededError",
+            &dom_exception,
+            |ctx, message: Opt<Undefined<Coerced<String>>>| {
+                let message = match message.0 {
+                    Some(Undefined(Some(m))) => m.0,
+                    _ => String::new(),
+                };
+                DOMException::new_with_name(&ctx, DOMExceptionName::QuotaExceededError, message)
+            },
+        )?;
+        let null = Value::new_null(ctx.clone());
+        let proto: Object = quota_exceeded_error.get(PredefinedAtom::Prototype)?;
+        proto.prop(
+            "requested",
+            Property::from(null.clone()).enumerable().configurable(),
+        )?;
+        proto.prop("quota", Property::from(null).enumerable().configurable())?;
+        ctx.globals().prop(
+            "QuotaExceededError",
+            Property::from(quota_exceeded_error)
+                .writable()
+                .configurable(),
+        )
+    }
 }
 
 macro_rules! create_dom_exception {
@@ -349,22 +387,14 @@ pub fn init(ctx: &Ctx<'_>) -> Result<()> {
     let primordials = BasePrimordials::get(ctx)?;
     dom_ex_proto.set_prototype(Some(&primordials.prototype_error))?;
 
-    if let Some(constructor) = Class::<QuotaExceededError>::create_constructor(ctx)? {
-        // the wpt tests expect this particular property descriptor
-        globals.prop(
-            QuotaExceededError::NAME,
-            Property::from(constructor).writable().configurable(),
-        )?;
-    }
-
-    let qee_ex_proto = Class::<QuotaExceededError>::prototype(ctx)?.unwrap();
-    qee_ex_proto.set_prototype(Some(&primordials.prototype_error))?;
+    DOMException::define_quota_exceeded_error(ctx)?;
 
     // `Error.isError(v)` only returns `true` for objects with QuickJS's
     // `[[ErrorData]]` internal slot (class id `JS_CLASS_ERROR`). There is
     // no public rquickjs API to tag a class-derived instance with that
     // slot, so we replace `Error.isError` with a version that also
-    // recognizes `DOMException` instances via `instanceof`.
+    // recognizes `DOMException` instances (and its subclasses) via
+    // `instanceof`.
     primordials
         .constructor_error
         .set("isError", Func::from(is_error))?;
@@ -380,9 +410,5 @@ fn is_error<'js>(ctx: Ctx<'js>, value: Value<'js>) -> Result<bool> {
         return Ok(false);
     };
     let dom_exception: Value = ctx.globals().get(DOMException::NAME)?;
-    if obj.is_instance_of(&dom_exception) {
-        return Ok(true);
-    }
-    let quota_exceeded_error: Value = ctx.globals().get(QuotaExceededError::NAME)?;
-    Ok(obj.is_instance_of(&quota_exceeded_error))
+    Ok(obj.is_instance_of(&dom_exception))
 }