construct_type_error and construct_range_error

Author: HalidOdat

boa/src/builtins/bigint/mod.rs

@@ -78,8 +78,7 @@ impl BigInt {
         }
 
         // 3. Throw a TypeError exception.
-        ctx.throw_type_error("'this' is not a BigInt")?;
-        unreachable!();
+        Err(ctx.construct_type_error("'this' is not a BigInt"))
     }
 
     /// `BigInt()`

boa/src/builtins/boolean/mod.rs

@@ -51,9 +51,7 @@ impl Boolean {
             _ => {}
         }
 
-        Err(ctx
-            .throw_type_error("'this' is not a boolean")
-            .expect_err("throw_type_error() did not return an error"))
+        Err(ctx.construct_type_error("'this' is not a boolean"))
     }
 
     /// `[[Construct]]` Create a new boolean object

boa/src/builtins/function/mod.rs

@@ -413,6 +413,9 @@ pub fn make_constructor_fn(
     prototype: Value,
     constructable: bool,
 ) -> Value {
+    let _timer =
+        BoaProfiler::global().start_event(&format!("make_constructor_fn: {}", name), "init");
+
     // Create the native function
     let mut function = Function::builtin(Vec::new(), body);
     function.constructable = constructable;
@@ -478,7 +481,7 @@ where
     N: Into<String>,
 {
     let name = name.into();
-    let _timer = BoaProfiler::global().start_event(&name, "make_builtin_fn");
+    let _timer = BoaProfiler::global().start_event(&format!("make_builtin_fn: {}", &name), "init");
 
     let mut function = Object::function(Function::builtin(Vec::new(), function));
     function.insert_field("length", Value::from(length));

boa/src/builtins/global_this/mod.rs

@@ -19,6 +19,7 @@ mod tests;
 pub(crate) struct GlobalThis;
 
 impl GlobalThis {
+    /// The binding name of the property.
     pub(crate) const NAME: &'static str = "globalThis";
 
     /// Initialize the `globalThis` property on the global object.

boa/src/builtins/nan/mod.rs

@@ -20,7 +20,7 @@ use crate::{builtins::value::Value, BoaProfiler};
 pub(crate) struct NaN;
 
 impl NaN {
-    /// The name of the property.
+    /// The binding name of the property.
     pub(crate) const NAME: &'static str = "NaN";
 
     /// Initialize the `NaN` property on the global object.

boa/src/builtins/number/mod.rs

@@ -68,9 +68,7 @@ impl Number {
             _ => {}
         }
 
-        Err(ctx
-            .throw_type_error("'this' is not a number")
-            .expect_err("throw_type_error() did not return an error"))
+        Err(ctx.construct_type_error("'this' is not a number"))
     }
 
     /// Helper function that formats a float as a ES6-style exponential number string.

boa/src/builtins/string/mod.rs

@@ -54,9 +54,7 @@ impl String {
             _ => {}
         }
 
-        Err(ctx
-            .throw_type_error("'this' is not a string")
-            .expect_err("throw_type_error() did not return an error"))
+        Err(ctx.construct_type_error("'this' is not a string"))
     }
 
     /// [[Construct]] - Creates a new instance `this`

boa/src/builtins/symbol/mod.rs

@@ -58,8 +58,7 @@ impl Symbol {
             _ => {}
         }
 
-        ctx.throw_type_error("'this' is not a Symbol")?;
-        unreachable!();
+        Err(ctx.construct_type_error("'this' is not a Symbol"))
     }
 
     /// The `Symbol()` constructor returns a value of type symbol.

boa/src/builtins/value/mod.rs

@@ -257,9 +257,9 @@ impl Value {
                 .map(JSONValue::Number)
                 .unwrap_or(JSONValue::Null)),
             ValueData::Integer(val) => Ok(JSONValue::Number(JSONNumber::from(val))),
-            ValueData::BigInt(_) => Err(interpreter
-                .throw_type_error("BigInt value can't be serialized in JSON")
-                .expect_err("throw_type_error should always return an error")),
+            ValueData::BigInt(_) => {
+                Err(interpreter.construct_type_error("BigInt value can't be serialized in JSON"))
+            }
             ValueData::Symbol(_) | ValueData::Undefined => {
                 unreachable!("Symbols and Undefined JSON Values depend on parent type");
             }

boa/src/exec/exception.rs

@@ -8,8 +8,8 @@ use crate::{
 };
 
 impl Interpreter {
-    /// Throws a `RangeError` with the specified message.
-    pub fn throw_range_error<M>(&mut self, message: M) -> ResultValue
+    /// Constructs a `RangeError` with the specified message.
+    pub fn construct_range_error<M>(&mut self, message: M) -> Value
     where
         M: Into<String>,
     {
@@ -19,10 +19,19 @@ impl Interpreter {
             vec![Const::from(message.into()).into()],
         ))
         .run(self)
+        .expect_err("RangeError should always throw")
     }
 
-    /// Throws a `TypeError` with the specified message.
-    pub fn throw_type_error<M>(&mut self, message: M) -> ResultValue
+    /// Throws a `RangeError` with the specified message.
+    pub fn throw_range_error<M>(&mut self, message: M) -> ResultValue
+    where
+        M: Into<String>,
+    {
+        Err(self.construct_range_error(message))
+    }
+
+    /// Constructs a `TypeError` with the specified message.
+    pub fn construct_type_error<M>(&mut self, message: M) -> Value
     where
         M: Into<String>,
     {
@@ -32,5 +41,30 @@ impl Interpreter {
             vec![Const::from(message.into()).into()],
         ))
         .run(self)
+        .expect_err("TypeError should always throw")
+    }
+
+    /// Throws a `TypeError` with the specified message.
+    pub fn throw_type_error<M>(&mut self, message: M) -> ResultValue
+    where
+        M: Into<String>,
+    {
+        Err(self.construct_type_error(message))
+    }
+
+    /// Constructs a `ReferenceError` with the specified message.
+    pub fn construct_reference_error<M>(&mut self, _message: M) -> Value
+    where
+        M: Into<String>,
+    {
+        unimplemented!("ReferenceError: is not implemented");
+    }
+
+    /// Throws a `ReferenceError` with the specified message.
+    pub fn throw_reference_error<M>(&mut self, message: M) -> ResultValue
+    where
+        M: Into<String>,
+    {
+        Err(self.construct_reference_error(message))
     }
 }