Implementation of for...of loops

boa/src/builtins/array/array_iterator.rs

@@ -0,0 +1,149 @@
+use crate::{
+    builtins::{
+        function::{make_builtin_fn, BuiltInFunction, Function, FunctionFlags},
+        Array, Value,
+    },
+    object::{Object, ObjectData, PROTOTYPE},
+    property::Property,
+    Context, Result,
+};
+use gc::{Finalize, Trace};
+use std::borrow::Borrow;
+
+#[derive(Debug, Clone, Finalize, Trace)]
+pub enum ArrayIterationKind {
+    Key,
+    Value,
+    KeyAndValue,
+}
+
+#[derive(Debug, Clone, Finalize, Trace)]
+pub struct ArrayIterator {
+    array: Value,
+    next_index: i32,
+    kind: ArrayIterationKind,
+}
+
+impl ArrayIterator {
+    fn new(array: Value, kind: ArrayIterationKind) -> Self {
+        ArrayIterator {
+            array,
+            kind,
+            next_index: 0,
+        }
+    }
+
+    pub(crate) fn new_array_iterator(
+        ctx: &Context,
+        array: Value,
+        kind: ArrayIterationKind,
+    ) -> Result<Value> {
+        let array_iterator = Value::new_object(Some(
+            &ctx.realm()
+                .environment
+                .get_global_object()
+                .expect("Could not get global object"),
+        ));
+        array_iterator.set_data(ObjectData::ArrayIterator(Self::new(array, kind)));
+        array_iterator
+            .as_object_mut()
+            .expect("array iterator object")
+            .set_prototype_instance(
+                ctx.realm()
+                    .environment
+                    .get_binding_value("Object")
+                    .expect("Object was not initialized")
+                    .borrow()
+                    .get_field(PROTOTYPE),
+            );
+        make_builtin_fn(Self::next, "next", &array_iterator, 0, ctx);
+        let mut function = Object::function(
+            Function::BuiltIn(
+                BuiltInFunction(|v, _, _| Ok(v.clone())),
+                FunctionFlags::CALLABLE,
+            ),
+            ctx.global_object()
+                .get_field("Function")
+                .get_field("prototype"),
+        );
+        function.insert_field("length", Value::from(0));
+
+        let symbol_iterator = ctx.well_known_symbols().iterator_symbol();
+        array_iterator.set_field(symbol_iterator, Value::from(function));
+        Ok(array_iterator)
+    }
+
+    pub(crate) fn next(this: &Value, _args: &[Value], ctx: &mut Context) -> Result<Value> {
+        if let Value::Object(ref object) = this {
+            let mut object = object.borrow_mut();
+            if let Some(array_iterator) = object.as_array_iterator_mut() {
+                let index = array_iterator.next_index;
+                if array_iterator.array.is_undefined() {
+                    return Ok(Self::create_iter_result_object(
+                        ctx,
+                        Value::undefined(),
+                        true,
+                    ));
+                }
+                let len = array_iterator
+                    .array
+                    .get_field("length")
+                    .as_number()
+                    .ok_or_else(|| ctx.construct_type_error("Not an array"))?
+                    as i32;
+                if array_iterator.next_index >= len {
+                    array_iterator.array = Value::undefined();
+                    return Ok(Self::create_iter_result_object(
+                        ctx,
+                        Value::undefined(),
+                        true,
+                    ));
+                }
+                array_iterator.next_index = index + 1;
+                match array_iterator.kind {
+                    ArrayIterationKind::Key => Ok(Self::create_iter_result_object(
+                        ctx,
+                        Value::integer(index),
+                        false,
+                    )),
+                    ArrayIterationKind::Value => {
+                        let element_value = array_iterator.array.get_field(index);
+                        Ok(Self::create_iter_result_object(ctx, element_value, false))
+                    }
+                    ArrayIterationKind::KeyAndValue => {
+                        let element_value = array_iterator.array.get_field(index);
+                        let result = Array::make_array(
+                            &Value::new_object(Some(
+                                &ctx.realm()
+                                    .environment
+                                    .get_global_object()
+                                    .expect("Could not get global object"),
+                            )),
+                            &[Value::integer(index), element_value],
+                            ctx,
+                        )?;
+                        Ok(result)
+                    }
+                }
+            } else {
+                ctx.throw_type_error("`this` is not an ArrayIterator")
+            }
+        } else {
+            ctx.throw_type_error("`this` is not an ArrayIterator")
+        }
+    }
+
+    fn create_iter_result_object(ctx: &mut Context, value: Value, done: bool) -> Value {
+        let object = Value::new_object(Some(
+            &ctx.realm()
+                .environment
+                .get_global_object()
+                .expect("Could not get global object"),
+        ));
+        let value_property = Property::default().value(value);
+        let done_property = Property::default().value(Value::boolean(done));
+        object.set_property("value", value_property);
+        object.set_property("done", done_property);
+        object
+    }
+}

boa/src/builtins/array/mod.rs

@@ -9,11 +9,13 @@
 //! [spec]: https://tc39.es/ecma262/#sec-array-objects
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
 
+pub mod array_iterator;
 #[cfg(test)]
 mod tests;
 
 use super::function::{make_builtin_fn, make_constructor_fn};
 use crate::{
+    builtins::array::array_iterator::{ArrayIterationKind, ArrayIterator},
     object::{ObjectData, PROTOTYPE},
     property::{Attribute, Property},
     value::{same_value_zero, Value},
@@ -1091,6 +1093,14 @@ impl Array {
         Ok(accumulator)
     }
 
+    pub(crate) fn values(
+        this: &Value,
+        _args: &[Value],
+        interpreter: &mut Context,
+    ) -> Result<Value> {
+        ArrayIterator::new_array_iterator(interpreter, this.clone(), ArrayIterationKind::Value)
+    }
+
     /// Initialise the `Array` object on the global object.
     #[inline]
     pub(crate) fn init(interpreter: &mut Context) -> (&'static str, Value) {
@@ -1137,6 +1147,13 @@ impl Array {
             2,
             interpreter,
         );
+        make_builtin_fn(Self::values, "values", &prototype, 0, interpreter);
+
+        let symbol_iterator = interpreter.well_known_symbols().iterator_symbol();
+        prototype.set_property(
+            symbol_iterator,
+            Property::default().value(prototype.get_field("values")),
+        );
 
         let array = make_constructor_fn(
             Self::NAME,

boa/src/builtins/mod.rs

@@ -49,6 +49,7 @@ pub fn init(interpreter: &mut Context) {
         // The `Function` global must be initialized before other types.
         function::init,
         Object::init,
+        Symbol::init,
         Array::init,
         BigInt::init,
         Boolean::init,
@@ -59,7 +60,6 @@ pub fn init(interpreter: &mut Context) {
         Number::init,
         RegExp::init,
         String::init,
-        Symbol::init,
         Console::init,
         // Global error types.
         Error::init,

boa/src/exec/declaration/mod.rs

@@ -81,7 +81,11 @@ impl Executable for VarDeclList {
 impl Executable for ConstDeclList {
     fn run(&self, interpreter: &mut Context) -> Result<Value> {
         for decl in self.as_ref() {
-            let val = decl.init().run(interpreter)?;
+            let val = if let Some(init) = decl.init() {
+                init.run(interpreter)?
+            } else {
+                return interpreter.throw_syntax_error("missing = in const declaration");
+            };
 
             interpreter
                 .realm_mut()