Initial implementation of Map()

boa/Cargo.toml

@@ -23,6 +23,7 @@ rustc-hash = "1.1.0"
 num-bigint = { version = "0.3.0", features = ["serde"] }
 num-integer = "0.1.43"
 bitflags = "1.2.1"
+indexmap = "1.4.0"
 
 # Optional Dependencies
 serde = { version = "1.0.114", features = ["derive"], optional = true }

boa/src/builtins/array/mod.rs

@@ -996,6 +996,7 @@ impl Array {
             global,
             prototype,
             true,
+            true,
         );
 
         // Static Methods

boa/src/builtins/bigint/mod.rs

@@ -215,6 +215,7 @@ impl BigInt {
             global,
             prototype,
             false,
+            true,
         );
 
         make_builtin_fn(Self::as_int_n, "asIntN", &bigint_object, 2);

boa/src/builtins/boolean/mod.rs

@@ -115,6 +115,7 @@ impl Boolean {
             global,
             prototype,
             true,
+            true,
         );
 
         (Self::NAME, boolean_object)

boa/src/builtins/error/mod.rs

@@ -92,6 +92,7 @@ impl Error {
             global,
             prototype,
             true,
+            true,
         );
 
         (Self::NAME, error_object)

boa/src/builtins/error/range.rs

@@ -78,6 +78,7 @@ impl RangeError {
             global,
             prototype,
             true,
+            true,
         );
 
         (Self::NAME, range_error_object)

boa/src/builtins/error/reference.rs

@@ -76,6 +76,7 @@ impl ReferenceError {
             global,
             prototype,
             true,
+            true,
         );
 
         (Self::NAME, reference_error_object)

boa/src/builtins/error/syntax.rs

@@ -80,6 +80,7 @@ impl SyntaxError {
             global,
             prototype,
             true,
+            true,
         );
 
         (Self::NAME, syntax_error_object)

boa/src/builtins/error/type.rs

@@ -84,6 +84,7 @@ impl TypeError {
             global,
             prototype,
             true,
+            true,
         );
 
         (Self::NAME, type_error_object)

boa/src/builtins/function/mod.rs

@@ -24,6 +24,7 @@ use crate::{
     syntax::ast::node::{FormalParameter, StatementList},
     BoaProfiler,
 };
+use bitflags::bitflags;
 use gc::{unsafe_empty_trace, Finalize, Trace};
 use std::fmt::{self, Debug};
 
@@ -90,6 +91,43 @@ unsafe impl Trace for FunctionBody {
     unsafe_empty_trace!();
 }
 
+bitflags! {
+    #[derive(Finalize, Default)]
+    struct FunctionFlags: u8 {
+        const CALLABLE = 0b0000_0001;
+        const CONSTRUCTABLE = 0b0000_0010;
+    }
+}
+
+impl FunctionFlags {
+    fn from_parameters(callable: bool, constructable: bool) -> Self {
+        let mut flags = Self::default();
+
+        if callable {
+            flags |= Self::CALLABLE;
+        }
+        if constructable {
+            flags |= Self::CONSTRUCTABLE;
+        }
+
+        flags
+    }
+
+    #[inline]
+    fn is_callable(&self) -> bool {
+        self.contains(Self::CALLABLE)
+    }
+
+    #[inline]
+    fn is_constructable(&self) -> bool {
+        self.contains(Self::CONSTRUCTABLE)
+    }
+}
+
+unsafe impl Trace for FunctionFlags {
+    unsafe_empty_trace!();
+}
+
 /// Boa representation of a Function Object.
 ///
 /// <https://tc39.es/ecma262/#sec-ecmascript-function-objects>
@@ -103,10 +141,8 @@ pub struct Function {
     pub this_mode: ThisMode,
     // Environment, built-in functions don't need Environments
     pub environment: Option<Environment>,
-    /// Is it constructable
-    constructable: bool,
-    /// Is it callable.
-    callable: bool,
+    /// Is it constructable or
+    flags: FunctionFlags,
 }
 
 impl Function {
@@ -126,8 +162,7 @@ impl Function {
             environment: scope,
             params: parameter_list.into(),
             this_mode,
-            constructable,
-            callable,
+            flags: FunctionFlags::from_parameters(callable, constructable),
         }
     }
 
@@ -183,7 +218,7 @@ impl Function {
         interpreter: &mut Interpreter,
     ) -> ResultValue {
         let _timer = BoaProfiler::global().start_event("function::call", "function");
-        if self.callable {
+        if self.flags.is_callable() {
             match self.body {
                 FunctionBody::BuiltIn(func) => func(this, args_list, interpreter),
                 FunctionBody::Ordinary(ref body) => {
@@ -249,7 +284,7 @@ impl Function {
         args_list: &[Value],
         interpreter: &mut Interpreter,
     ) -> ResultValue {
-        if self.constructable {
+        if self.flags.is_constructable() {
             match self.body {
                 FunctionBody::BuiltIn(func) => {
                     func(this, args_list, interpreter)?;
@@ -351,12 +386,12 @@ impl Function {
 
     /// Returns true if the function object is callable.
     pub fn is_callable(&self) -> bool {
-        self.callable
+        self.flags.is_callable()
     }
 
     /// Returns true if the function object is constructable.
     pub fn is_constructable(&self) -> bool {
-        self.constructable
+        self.flags.is_constructable()
     }
 }
 
@@ -420,13 +455,14 @@ pub fn make_constructor_fn(
     global: &Value,
     prototype: Value,
     constructable: bool,
+    callable: 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;
+    function.flags = FunctionFlags::from_parameters(callable, constructable);
 
     let mut constructor = Object::function(function);
 
@@ -507,7 +543,7 @@ pub fn init(global: &Value) -> (&str, Value) {
     let prototype = Value::new_object(Some(global));
 
     let function_object =
-        make_constructor_fn("Function", 1, make_function, global, prototype, true);
+        make_constructor_fn("Function", 1, make_function, global, prototype, true, true);
 
     ("Function", function_object)
 }