Implement arguments exotic object

boa/examples/classes.rs

@@ -14,7 +14,7 @@ use boa::{
 //
 // The fields of the struct are not accessible by Javascript unless we create accessors for them.
 /// Represents a `Person` object.
-#[derive(Debug, Trace, Finalize)]
+#[derive(Debug, Clone, Trace, Finalize)]
 struct Person {
     /// The name of the person.
     name: String,

boa/src/builtins/array/mod.rs

@@ -39,19 +39,11 @@ impl BuiltIn for Array {
     fn init(context: &mut Context) -> (&'static str, JsValue, Attribute) {
         let _timer = BoaProfiler::global().start_event(Self::NAME, "init");
 
-        let symbol_iterator = WellKnownSymbols::iterator();
-
         let get_species = FunctionBuilder::native(context, Self::get_species)
             .name("get [Symbol.species]")
             .constructable(false)
             .build();
 
-        let values_function = FunctionBuilder::native(context, Self::values)
-            .name("values")
-            .length(0)
-            .constructable(false)
-            .build();
-
         let array = ConstructorBuilder::with_standard_object(
             context,
             Self::constructor,
@@ -70,16 +62,8 @@ impl BuiltIn for Array {
             0,
             Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::PERMANENT,
         )
-        .property(
-            "values",
-            values_function.clone(),
-            Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
-        )
-        .property(
-            symbol_iterator,
-            values_function,
-            Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
-        )
+        .method(Self::values, "values", 0)
+        .method(Self::values, (WellKnownSymbols::iterator(), "values"), 0)
         .method(Self::concat, "concat", 1)
         .method(Self::push, "push", 1)
         .method(Self::index_of, "indexOf", 1)

boa/src/builtins/function/mod.rs

@@ -11,7 +11,7 @@
 //! [spec]: https://tc39.es/ecma262/#sec-function-objects
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function
 
-use crate::object::PROTOTYPE;
+use crate::object::{NativeObject, PROTOTYPE};
 use crate::{
     builtins::{Array, BuiltIn},
     environment::lexical_environment::Environment,
@@ -51,13 +51,18 @@ pub type NativeFunction = fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsV
 /// be callable from Javascript, but most of the time the compiler
 /// is smart enough to correctly infer the types.
 pub trait ClosureFunction:
-    Fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsValue> + DynCopy + DynClone + 'static
+    Fn(&JsValue, &[JsValue], &mut Context, Box<dyn NativeObject>) -> JsResult<JsValue>
+    + DynCopy
+    + DynClone
+    + 'static
 {
 }
 
 // The `Copy` bound automatically infers `DynCopy` and `DynClone`
 impl<T> ClosureFunction for T where
-    T: Fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsValue> + Copy + 'static
+    T: Fn(&JsValue, &[JsValue], &mut Context, Box<dyn NativeObject>) -> JsResult<JsValue>
+        + Copy
+        + 'static
 {
 }
 
@@ -122,6 +127,7 @@ pub enum Function {
         #[unsafe_ignore_trace]
         function: Box<dyn ClosureFunction>,
         constructable: bool,
+        captures: Box<dyn NativeObject>,
     },
     Ordinary {
         flags: FunctionFlags,
@@ -193,44 +199,6 @@ impl Function {
     }
 }
 
-/// Arguments.
-///
-/// <https://tc39.es/ecma262/#sec-createunmappedargumentsobject>
-pub fn create_unmapped_arguments_object(
-    arguments_list: &[JsValue],
-    context: &mut Context,
-) -> JsResult<JsValue> {
-    let len = arguments_list.len();
-    let obj = JsObject::new(Object::default());
-    // Set length
-    let length = PropertyDescriptor::builder()
-        .value(len)
-        .writable(true)
-        .enumerable(false)
-        .configurable(true);
-    // Define length as a property
-    crate::object::internal_methods::ordinary_define_own_property(
-        &obj,
-        "length".into(),
-        length.into(),
-        context,
-    )?;
-    let mut index: usize = 0;
-    while index < len {
-        let val = arguments_list.get(index).expect("Could not get argument");
-        let prop = PropertyDescriptor::builder()
-            .value(val.clone())
-            .writable(true)
-            .enumerable(true)
-            .configurable(true);
-
-        obj.insert(index, prop);
-        index += 1;
-    }
-
-    Ok(JsValue::new(obj))
-}
-
 /// Creates a new member function of a `Object` or `prototype`.
 ///
 /// A function registered using this macro can then be called from Javascript using:

boa/src/builtins/intrinsics.rs

@@ -0,0 +1,50 @@
+use crate::{
+    builtins::function::BuiltInFunction,
+    object::{JsObject, Object},
+    property::PropertyDescriptor,
+    Context, JsResult, JsValue,
+};
+
+use super::function::Function;
+
+#[derive(Debug, Default)]
+pub struct Intrinsics {
+    throw_type_error: JsObject,
+}
+
+impl Intrinsics {
+    pub fn init(context: &mut Context) -> Intrinsics {
+        Self {
+            throw_type_error: create_throw_type_error(context),
+        }
+    }
+
+    pub fn throw_type_error(&self) -> JsObject {
+        self.throw_type_error.clone()
+    }
+}
+
+fn create_throw_type_error(context: &mut Context) -> JsObject {
+    fn throw_type_error(_: &JsValue, _: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
+        context.throw_type_error("generic type error")
+    }
+    let mut function = Object::function(
+        Function::Native {
+            function: BuiltInFunction(throw_type_error),
+            constructable: false,
+        },
+        context
+            .standard_objects()
+            .function_object()
+            .prototype()
+            .into(),
+    );
+    let property = PropertyDescriptor::builder()
+        .writable(false)
+        .enumerable(false)
+        .configurable(false);
+    function.insert_property("name", property.clone().value("ThrowTypeError"));
+    function.insert_property("length", property.value(0));
+
+    JsObject::new(function)
+}

boa/src/builtins/mod.rs

@@ -13,6 +13,7 @@ pub mod error;
 pub mod function;
 pub mod global_this;
 pub mod infinity;
+pub mod intrinsics;
 pub mod iterable;
 pub mod json;
 pub mod map;

boa/src/builtins/object/mod.rs

@@ -475,7 +475,7 @@ impl Object {
             let o = o.borrow();
             match o.kind() {
                 ObjectKind::Array => "Array",
-                // TODO: Arguments Exotic Objects are currently not supported
+                ObjectKind::Arguments(_) => "Arguments",
                 ObjectKind::Function(_) => "Function",
                 ObjectKind::Error => "Error",
                 ObjectKind::Boolean(_) => "Boolean",

boa/src/context.rs

@@ -4,6 +4,7 @@ use crate::{
     builtins::{
         self,
         function::{Function, FunctionFlags, NativeFunction},
+        intrinsics::Intrinsics,
         iterable::IteratorPrototypes,
     },
     class::{Class, ClassBuilder},
@@ -86,7 +87,7 @@ pub struct StandardObjects {
     symbol: StandardConstructor,
     error: StandardConstructor,
     type_error: StandardConstructor,
-    referece_error: StandardConstructor,
+    reference_error: StandardConstructor,
     range_error: StandardConstructor,
     syntax_error: StandardConstructor,
     eval_error: StandardConstructor,
@@ -109,7 +110,7 @@ impl Default for StandardObjects {
             symbol: StandardConstructor::default(),
             error: StandardConstructor::default(),
             type_error: StandardConstructor::default(),
-            referece_error: StandardConstructor::default(),
+            reference_error: StandardConstructor::default(),
             range_error: StandardConstructor::default(),
             syntax_error: StandardConstructor::default(),
             eval_error: StandardConstructor::default(),
@@ -173,7 +174,7 @@ impl StandardObjects {
 
     #[inline]
     pub fn reference_error_object(&self) -> &StandardConstructor {
-        &self.referece_error
+        &self.reference_error
     }
 
     #[inline]
@@ -271,6 +272,9 @@ pub struct Context {
     /// Cached standard objects and their prototypes.
     standard_objects: StandardObjects,
 
+    /// Cached intrinsic objects
+    intrinsics: Intrinsics,
+
     /// Whether or not to show trace of instructions being ran
     pub trace: bool,
 }
@@ -285,15 +289,17 @@ impl Default for Context {
             #[cfg(feature = "console")]
             console: Console::default(),
             iterator_prototypes: IteratorPrototypes::default(),
+            intrinsics: Intrinsics::default(),
             standard_objects: Default::default(),
             trace: false,
         };
 
         // Add new builtIns to Context Realm
         // At a later date this can be removed from here and called explicitly,
         // but for now we almost always want these default builtins
-        context.create_intrinsics();
+        context.init_builtins();
         context.iterator_prototypes = IteratorPrototypes::init(&mut context);
+        context.intrinsics = Intrinsics::init(&mut context);
         context
     }
 }
@@ -325,9 +331,9 @@ impl Context {
 
     /// Sets up the default global objects within Global
     #[inline]
-    fn create_intrinsics(&mut self) {
-        let _timer = BoaProfiler::global().start_event("create_intrinsics", "interpreter");
-        // Create intrinsics, add global objects here
+    fn init_builtins(&mut self) {
+        let _timer = BoaProfiler::global().start_event("init_builtins", "interpreter");
+        // Create builtin objects, add global objects here
         builtins::init(self);
     }
 
@@ -853,6 +859,12 @@ impl Context {
         &self.standard_objects
     }
 
+    /// Return the intrinsics.
+    #[inline]
+    pub fn intrinsics(&self) -> &Intrinsics {
+        &self.intrinsics
+    }
+
     /// Set the value of trace on the context
     pub fn set_trace(&mut self, trace: bool) {
         self.trace = trace;