Add DomExceptionName

Author: jackkleeman

modules/llrt_abort/src/abort_signal.rs

@@ -3,7 +3,7 @@
 use std::sync::{Arc, RwLock};
 
 use llrt_events::{Emitter, EventEmitter, EventList};
-use llrt_exceptions::DOMException;
+use llrt_exceptions::{DOMException, DOMExceptionName};
 use llrt_utils::mc_oneshot;
 use rquickjs::{
     class::{Trace, Tracer},
@@ -160,7 +160,11 @@ impl<'js> AbortSignal<'js> {
     pub fn send_aborted(this: This<Class<'js, Self>>, ctx: Ctx<'js>) -> Result<()> {
         let mut borrow = this.borrow_mut();
         borrow.aborted = true;
-        let reason = get_reason_or_dom_exception(&ctx, borrow.reason.as_ref(), "AbortError")?;
+        let reason = get_reason_or_dom_exception(
+            &ctx,
+            borrow.reason.as_ref(),
+            DOMExceptionName::AbortError,
+        )?;
         borrow.reason = Some(reason.clone());
         borrow.sender.send(reason);
         drop(borrow);
@@ -179,7 +183,8 @@ impl<'js> AbortSignal<'js> {
 
     #[qjs(static)]
     pub fn timeout(ctx: Ctx<'js>, milliseconds: u64) -> Result<Class<'js, Self>> {
-        let timeout_error = get_reason_or_dom_exception(&ctx, None, "TimeoutError")?;
+        let timeout_error =
+            get_reason_or_dom_exception(&ctx, None, DOMExceptionName::TimeoutError)?;
 
         let signal = Self::new();
         let signal_instance = Class::instance(ctx.clone(), signal)?;
@@ -221,12 +226,12 @@ impl<'js> AbortSignal<'js> {
 fn get_reason_or_dom_exception<'js>(
     ctx: &Ctx<'js>,
     reason: Option<&Value<'js>>,
-    name: &str,
+    name: DOMExceptionName,
 ) -> Result<Value<'js>> {
     let reason = if let Some(reason) = reason {
         reason.clone()
     } else {
-        let ex = DOMException::new(ctx.clone(), Opt(None), Opt(Some(name.into())))?;
+        let ex = DOMException::new_with_name(ctx, name, String::new())?;
         Class::instance(ctx.clone(), ex)?.into_value()
     };
     Ok(reason)

modules/llrt_exceptions/src/lib.rs

@@ -1,61 +1,43 @@
-use llrt_utils::primordials::{BasePrimordials, Primordial};
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-use rquickjs::{atom::PredefinedAtom, function::Opt, Class, Ctx, Object, Result};
+use llrt_utils::primordials::{BasePrimordials, Primordial};
+use rquickjs::{atom::PredefinedAtom, function::Opt, Class, Coerced, Ctx, Object, Result};
 
 #[rquickjs::class]
 #[derive(rquickjs::class::Trace, rquickjs::JsLifetime)]
 pub struct DOMException {
-    message: String,
     name: String,
+    message: String,
     stack: String,
     code: u8,
 }
 
 #[rquickjs::methods]
 impl DOMException {
     #[qjs(constructor)]
-    pub fn new(ctx: Ctx<'_>, message: Opt<String>, name: Opt<String>) -> Result<Self> {
-        let primordials = BasePrimordials::get(&ctx)?;
+    pub fn new(ctx: Ctx<'_>, message: Opt<String>, name: Opt<Coerced<String>>) -> Result<Self> {
+        let message = message.0.unwrap_or_default();
+
+        let name = name
+            .0
+            .map(|name| DOMExceptionName::from(name.0))
+            .unwrap_or(DOMExceptionName::Error);
+
+        Self::new_with_name(&ctx, name, message)
+    }
+
+    #[qjs(skip)]
+    pub fn new_with_name(ctx: &Ctx<'_>, name: DOMExceptionName, message: String) -> Result<Self> {
+        let primordials = BasePrimordials::get(ctx)?;
 
         let new: Object = primordials
             .constructor_error
             .construct((message.clone(),))?;
 
-        let message = message.0.unwrap_or(String::from(""));
-        let name = name.0.unwrap_or(String::from("Error"));
-
-        // https://webidl.spec.whatwg.org/#dfn-error-names-table
-        let code = match name.as_str() {
-            "IndexSizeError" => 1,
-            "HierarchyRequestError" => 3,
-            "WrongDocumentError" => 4,
-            "InvalidCharacterError" => 5,
-            "NoModificationAllowedError" => 7,
-            "NotFoundError" => 8,
-            "NotSupportedError" => 9,
-            "InUseAttributeError" => 10,
-            "InvalidStateError" => 11,
-            "SyntaxError" => 12,
-            "InvalidModificationError" => 13,
-            "NamespaceError" => 14,
-            "InvalidAccessError" => 15,
-            "TypeMismatchError" => 17,
-            "SecurityError" => 18,
-            "NetworkError" => 19,
-            "AbortError" => 20,
-            "URLMismatchError" => 21,
-            "QuotaExceededError" => 22,
-            "TimeoutError" => 23,
-            "InvalidNodeTypeError" => 24,
-            "DataCloneError" => 25,
-            _ => 0,
-        };
-
         Ok(Self {
+            name: format!("{:?}", name),
+            code: name.code(),
             message,
-            name,
-            code,
             stack: new.get::<_, String>(PredefinedAtom::Stack)?,
         })
     }
@@ -66,8 +48,8 @@ impl DOMException {
     }
 
     #[qjs(get)]
-    pub fn name(&self) -> String {
-        self.name.clone()
+    pub fn name(&self) -> &str {
+        self.name.as_str()
     }
 
     #[qjs(get)]
@@ -84,10 +66,112 @@ impl DOMException {
     #[qjs(rename = PredefinedAtom::ToString)]
     pub fn to_string(&self) -> String {
         if self.message.is_empty() {
-            return self.name.clone();
+            return self.name().to_string();
         }
 
-        [self.name.as_str(), self.message.as_str()].join(": ")
+        [self.name(), self.message.as_str()].join(": ")
+    }
+}
+
+macro_rules! create_dom_exception {
+    ($name:ident, $($variant:ident),+ $(,)?) => {
+        #[derive(Debug)]
+        pub enum $name {
+            $(
+                $variant,
+            )+
+            Other(String),
+        }
+
+        impl $name {
+            pub fn as_str(&self) -> &str {
+                match self {
+                    $(
+                        Self::$variant => stringify!($variant),
+                    )+
+                    Self::Other(value) => value,
+                }
+            }
+        }
+
+        impl From<String> for $name {
+            fn from(value: String) -> Self {
+                match value.as_str() {
+                    $(
+                        stringify!($variant) => Self::$variant,
+                    )+
+                    _ => Self::Other(value),
+                }
+            }
+        }
+    };
+}
+
+// https://webidl.spec.whatwg.org/#dfn-error-names-table
+create_dom_exception!(
+    DOMExceptionName,
+    IndexSizeError,
+    HierarchyRequestError,
+    WrongDocumentError,
+    InvalidCharacterError,
+    NoModificationAllowedError,
+    NotFoundError,
+    NotSupportedError,
+    InUseAttributeError,
+    InvalidStateError,
+    SyntaxError,
+    InvalidModificationError,
+    NamespaceError,
+    InvalidAccessError,
+    TypeMismatchError,
+    SecurityError,
+    NetworkError,
+    AbortError,
+    URLMismatchError,
+    QuotaExceededError,
+    TimeoutError,
+    InvalidNodeTypeError,
+    DataCloneError,
+    EncodingError,
+    NotReadableError,
+    UnknownError,
+    ConstraintError,
+    DataError,
+    TransactionInactiveError,
+    ReadOnlyError,
+    VersionError,
+    OperationError,
+    NotAllowedError,
+    Error,
+);
+
+impl DOMExceptionName {
+    fn code(&self) -> u8 {
+        match self {
+            DOMExceptionName::IndexSizeError => 1,
+            DOMExceptionName::HierarchyRequestError => 3,
+            DOMExceptionName::WrongDocumentError => 4,
+            DOMExceptionName::InvalidCharacterError => 5,
+            DOMExceptionName::NoModificationAllowedError => 7,
+            DOMExceptionName::NotFoundError => 8,
+            DOMExceptionName::NotSupportedError => 9,
+            DOMExceptionName::InUseAttributeError => 10,
+            DOMExceptionName::InvalidStateError => 11,
+            DOMExceptionName::SyntaxError => 12,
+            DOMExceptionName::InvalidModificationError => 13,
+            DOMExceptionName::NamespaceError => 14,
+            DOMExceptionName::InvalidAccessError => 15,
+            DOMExceptionName::TypeMismatchError => 17,
+            DOMExceptionName::SecurityError => 18,
+            DOMExceptionName::NetworkError => 19,
+            DOMExceptionName::AbortError => 20,
+            DOMExceptionName::URLMismatchError => 21,
+            DOMExceptionName::QuotaExceededError => 22,
+            DOMExceptionName::TimeoutError => 23,
+            DOMExceptionName::InvalidNodeTypeError => 24,
+            DOMExceptionName::DataCloneError => 25,
+            _ => 0,
+        }
     }
 }