Divide the run() function

boa/src/exec/mod.rs

@@ -5,6 +5,7 @@ mod block;
 mod declaration;
 mod expression;
 mod iteration;
+mod object;
 mod operator;
 mod statement_list;
 #[cfg(test)]
@@ -24,7 +25,7 @@ use crate::{
     realm::Realm,
     syntax::ast::{
         constant::Const,
-        node::{FormalParameter, MethodDefinitionKind, Node, PropertyDefinition, StatementList},
+        node::{FormalParameter, Node, StatementList},
     },
 };
 use std::{borrow::Borrow, ops::Deref};
@@ -447,36 +448,7 @@ impl Executable for Node {
                 }
                 Ok(result)
             }
-            Node::Object(ref properties) => {
-                let global_val = &interpreter
-                    .realm()
-                    .environment
-                    .get_global_object()
-                    .expect("Could not get the global object");
-                let obj = Value::new_object(Some(global_val));
-
-                // TODO: Implement the rest of the property types.
-                for property in properties.iter() {
-                    match property {
-                        PropertyDefinition::Property(key, value) => {
-                            obj.borrow()
-                                .set_field(&key.clone(), value.run(interpreter)?);
-                        }
-                        PropertyDefinition::MethodDefinition(kind, name, func) => {
-                            if let MethodDefinitionKind::Ordinary = kind {
-                                obj.borrow()
-                                    .set_field(&name.clone(), func.run(interpreter)?);
-                            } else {
-                                // TODO: Implement other types of MethodDefinitionKinds.
-                                unimplemented!("other types of property method definitions.");
-                            }
-                        }
-                        i => unimplemented!("{:?} type of property", i),
-                    }
-                }
-
-                Ok(obj)
-            }
+            Node::Object(ref obj) => obj.run(interpreter),
             Node::ArrayDecl(ref arr) => arr.run(interpreter),
             // <https://tc39.es/ecma262/#sec-createdynamicfunction>
             Node::FunctionDecl(ref decl) => decl.run(interpreter),

boa/src/exec/object/mod.rs

@@ -0,0 +1,43 @@
+//! Object execution.
+
+use super::{Executable, Interpreter};
+use crate::{
+    builtins::value::{ResultValue, Value},
+    syntax::ast::node::MethodDefinitionKind,
+    syntax::ast::node::{Object, PropertyDefinition},
+};
+
+use std::borrow::Borrow;
+
+impl Executable for Object {
+    fn run(&self, interpreter: &mut Interpreter) -> ResultValue {
+        let global_val = &interpreter
+            .realm()
+            .environment
+            .get_global_object()
+            .expect("Could not get the global object");
+        let obj = Value::new_object(Some(global_val));
+
+        // TODO: Implement the rest of the property types.
+        for property in self.properties().iter() {
+            match property {
+                PropertyDefinition::Property(key, value) => {
+                    obj.borrow()
+                        .set_field(&key.clone(), value.run(interpreter)?);
+                }
+                PropertyDefinition::MethodDefinition(kind, name, func) => {
+                    if let MethodDefinitionKind::Ordinary = kind {
+                        obj.borrow()
+                            .set_field(&name.clone(), func.run(interpreter)?);
+                    } else {
+                        // TODO: Implement other types of MethodDefinitionKinds.
+                        unimplemented!("other types of property method definitions.");
+                    }
+                }
+                i => unimplemented!("{:?} type of property", i),
+            }
+        }
+
+        Ok(obj)
+    }
+}

boa/src/syntax/ast/node/mod.rs

@@ -6,6 +6,7 @@ pub mod declaration;
 pub mod expression;
 pub mod identifier;
 pub mod iteration;
+pub mod object;
 pub mod operator;
 pub mod statement_list;
 pub mod try_node;
@@ -20,6 +21,7 @@ pub use self::{
     expression::{Call, New},
     identifier::Identifier,
     iteration::ForLoop,
+    object::Object,
     operator::{Assign, BinOp, UnaryOp},
     statement_list::StatementList,
     try_node::{Catch, Finally, Try},
@@ -214,26 +216,8 @@ pub enum Node {
     /// A `new` expression. [More information](./expression/struct.New.html).
     New(New),
 
-    /// Objects in JavaScript may be defined as an unordered collection of related data, of
-    /// primitive or reference types, in the form of “key: value” pairs.
-    ///
-    /// Objects can be initialized using `new Object()`, `Object.create()`, or using the literal
-    /// notation.
-    ///
-    /// An object initializer is an expression that describes the initialization of an
-    /// [`Object`][object]. Objects consist of properties, which are used to describe an object.
-    /// Values of object properties can either contain [`primitive`][primitive] data types or other
-    /// objects.
-    ///
-    /// More information:
-    ///  - [ECMAScript reference][spec]
-    ///  - [MDN documentation][mdn]
-    ///
-    /// [spec]: https://tc39.es/ecma262/#prod-ObjectLiteral
-    /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
-    /// [object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
-    /// [primitive]: https://developer.mozilla.org/en-US/docs/Glossary/primitive
-    Object(Box<[PropertyDefinition]>),
+    /// An object. [More information](./object/struct.Object.html).
+    Object(Object),
 
     /// The `return` statement ends function execution and specifies a value to be returned to the
     /// function caller.
@@ -442,14 +426,6 @@ impl Node {
         )
     }
 
-    /// Creates an `Object` AST node.
-    pub fn object<D>(def: D) -> Self
-    where
-        D: Into<Box<[PropertyDefinition]>>,
-    {
-        Self::Object(def.into())
-    }
-
     /// Creates a `Return` AST node.
     pub fn return_node<E, OE>(expr: OE) -> Self
     where
@@ -582,27 +558,7 @@ impl Node {
                 def.display(f, indentation + 1)?;
                 write!(f, "{}}}", indent)
             }
-            Self::Object(ref properties) => {
-                f.write_str("{\n")?;
-                for property in properties.iter() {
-                    match property {
-                        PropertyDefinition::IdentifierReference(key) => {
-                            write!(f, "{}    {},", indent, key)?;
-                        }
-                        PropertyDefinition::Property(key, value) => {
-                            write!(f, "{}    {}: {},", indent, key, value)?;
-                        }
-                        PropertyDefinition::SpreadObject(key) => {
-                            write!(f, "{}    ...{},", indent, key)?;
-                        }
-                        PropertyDefinition::MethodDefinition(_kind, _key, _node) => {
-                            // TODO: Implement display for PropertyDefinition::MethodDefinition.
-                            unimplemented!("Display for PropertyDefinition::MethodDefinition");
-                        }
-                    }
-                }
-                f.write_str("}")
-            }
+            Self::Object(ref obj) => obj.display(f, indentation),
             Self::ArrayDecl(ref arr) => Display::fmt(arr, f),
             Self::VarDeclList(ref list) => Display::fmt(list, f),
             Self::FunctionDecl(ref decl) => decl.display(f, indentation),

boa/src/syntax/ast/node/object.rs

@@ -0,0 +1,88 @@
+//! Object node.
+
+use super::Node;
+use gc::{Finalize, Trace};
+use std::fmt;
+
+use crate::syntax::ast::node::PropertyDefinition;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// Objects in JavaScript may be defined as an unordered collection of related data, of
+/// primitive or reference types, in the form of “key: value” pairs.
+///
+/// Objects can be initialized using `new Object()`, `Object.create()`, or using the literal
+/// notation.
+///
+/// An object initializer is an expression that describes the initialization of an
+/// [`Object`][object]. Objects consist of properties, which are used to describe an object.
+/// Values of object properties can either contain [`primitive`][primitive] data types or other
+/// objects.
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///  - [MDN documentation][mdn]
+///
+/// [spec]: https://tc39.es/ecma262/#prod-ObjectLiteral
+/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
+/// [object]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
+/// [primitive]: https://developer.mozilla.org/en-US/docs/Glossary/primitive
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
+pub struct Object {
+    properties: Box<[PropertyDefinition]>,
+}
+
+impl Object {
+    /// Creates an `Object` AST node.
+    pub fn new<D>(props: D) -> Self
+    where
+        D: Into<Box<[PropertyDefinition]>>,
+    {
+        Self {
+            properties: props.into(),
+        }
+    }
+
+    pub fn properties(&self) -> &[PropertyDefinition] {
+        &self.properties
+    }
+
+    /// Implements the display formatting with indentation.
+    pub(super) fn display(&self, f: &mut fmt::Formatter<'_>, indent: usize) -> fmt::Result {
+        f.write_str("{\n")?;
+        for property in self.properties().iter() {
+            match property {
+                PropertyDefinition::IdentifierReference(key) => {
+                    write!(f, "{}    {},", indent, key)?;
+                }
+                PropertyDefinition::Property(key, value) => {
+                    write!(f, "{}    {}: {},", indent, key, value)?;
+                }
+                PropertyDefinition::SpreadObject(key) => {
+                    write!(f, "{}    ...{},", indent, key)?;
+                }
+                PropertyDefinition::MethodDefinition(_kind, _key, _node) => {
+                    // TODO: Implement display for PropertyDefinition::MethodDefinition.
+                    unimplemented!("Display for PropertyDefinition::MethodDefinition");
+                }
+            }
+        }
+        f.write_str("}")
+    }
+}
+
+impl fmt::Display for Object {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display(f, 0)
+    }
+}
+
+impl From<Object> for Node {
+    fn from(obj: Object) -> Self {
+        Self::Object(obj)
+    }
+}

boa/src/syntax/parser/expression/primary/object_initializer/mod.rs

@@ -12,7 +12,7 @@ mod tests;
 
 use crate::syntax::{
     ast::{
-        node::{self, FunctionExpr, MethodDefinitionKind, Node},
+        node::{self, FunctionExpr, MethodDefinitionKind, Node, Object},
         token::{Token, TokenKind},
         Punctuator,
     },
@@ -82,7 +82,7 @@ impl TokenParser for ObjectLiteral {
             }
         }
 
-        Ok(Node::object(elements))
+        Ok(Object::new(elements).into())
     }
 }
 

boa/src/syntax/parser/expression/primary/object_initializer/tests.rs

@@ -1,8 +1,8 @@
 use crate::syntax::{
     ast::{
         node::{
-            ConstDecl, ConstDeclList, FormalParameter, FunctionExpr, MethodDefinitionKind, Node,
-            PropertyDefinition,
+            ConstDecl, ConstDeclList, FormalParameter, FunctionExpr, MethodDefinitionKind,
+            Object, PropertyDefinition,
         },
         Const,
     },
@@ -23,9 +23,7 @@ fn check_object_literal() {
             b: false,
         };
         ",
-        vec![
-            ConstDeclList::from(vec![ConstDecl::new("x", Node::object(object_properties))]).into(),
-        ],
+        vec![ConstDeclList::from(vec![ConstDecl::new("x", Object::new(object_properties))]).into()],
     );
 }
 
@@ -47,9 +45,7 @@ fn check_object_short_function() {
             b() {},
         };
         ",
-        vec![
-            ConstDeclList::from(vec![ConstDecl::new("x", Node::object(object_properties))]).into(),
-        ],
+        vec![ConstDeclList::from(vec![ConstDecl::new("x", Object::new(object_properties))]).into()],
     );
 }
 
@@ -75,9 +71,7 @@ fn check_object_short_function_arguments() {
             b(test) {}
          };
         ",
-        vec![
-            ConstDeclList::from(vec![ConstDecl::new("x", Node::object(object_properties))]).into(),
-        ],
+        vec![ConstDeclList::from(vec![ConstDecl::new("x", Object::new(object_properties))]).into()],
     );
 }
 
@@ -98,9 +92,7 @@ fn check_object_getter() {
             get b() {}
         };
         ",
-        vec![
-            ConstDeclList::from(vec![ConstDecl::new("x", Node::object(object_properties))]).into(),
-        ],
+        vec![ConstDeclList::from(vec![ConstDecl::new("x", Object::new(object_properties))]).into()],
     );
 }
 
@@ -125,8 +117,6 @@ fn check_object_setter() {
             set b(test) {}
         };
         ",
-        vec![
-            ConstDeclList::from(vec![ConstDecl::new("x", Node::object(object_properties))]).into(),
-        ],
+        vec![ConstDeclList::from(vec![ConstDecl::new("x", Object::new(object_properties))]).into()],
     );
 }