Implement dynamic imports (#2932)

* WIP: 76d7eceed6 Implement dynamic imports

* Expand `ActiveRunnable` to missing places

* Fix memory leak

* Fix docs

* Parse `import` as call expression

* Fix regressions

* Fix copypasted doc

* clippy fix

* Adjust ignored features

* Migrate away from `top_level_*` operations

* Fix more module tests

* Fix doc link

boa_ast/src/declaration/export.rs

@@ -22,7 +22,9 @@ use crate::{
 use boa_interner::Sym;
 
 /// The kind of re-export in an [`ExportDeclaration`].
-#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ReExportKind {
     /// Namespaced Re-export (`export * as name from "module-name"`).
     Namespaced {
@@ -76,7 +78,8 @@ impl VisitWith for ReExportKind {
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ExportDeclaration
-#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ExportDeclaration {
     /// Re-export.
     ReExport {
@@ -165,7 +168,9 @@ impl VisitWith for ExportDeclaration {
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ExportSpecifier
-#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Clone, Debug, Copy, PartialEq, Eq)]
 pub struct ExportSpecifier {
     alias: Sym,
     private_name: Sym,

boa_ast/src/declaration/import.rs

@@ -21,7 +21,9 @@ use boa_interner::Sym;
 use super::ModuleSpecifier;
 
 /// The kind of import in an [`ImportDeclaration`].
-#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ImportKind {
     /// Default (`import defaultName from "module-name"`) or unnamed (`import "module-name").
     DefaultOrUnnamed,
@@ -77,7 +79,8 @@ impl VisitWith for ImportKind {
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ImportDeclaration
-#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ImportDeclaration {
     /// Binding for the default export of `specifier`.
     default: Option<Identifier>,
@@ -155,7 +158,9 @@ impl VisitWith for ImportDeclaration {
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ImportSpecifier
-#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ImportSpecifier {
     binding: Identifier,
     export_name: Sym,

boa_ast/src/declaration/mod.rs

@@ -105,7 +105,9 @@ impl VisitWith for Declaration {
 /// This is equivalent to the [`ModuleSpecifier`] production.
 ///
 /// [`FromClause`]: https://tc39.es/ecma262/#prod-ModuleSpecifier
-#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Clone, Debug, Copy, PartialEq, Eq)]
 pub struct ModuleSpecifier {
     module: Sym,
 }

boa_ast/src/expression/call.rs

@@ -162,3 +162,68 @@ impl VisitWith for SuperCall {
         ControlFlow::Continue(())
     }
 }
+
+/// The import() syntax, commonly called dynamic import, is a function-like expression that allows
+/// loading an ECMAScript module asynchronously and dynamically into a potentially non-module
+/// environment.
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///  - [MDN documentation][mdn]
+///
+/// [spec]: https://tc39.es/ecma262/#prod-ImportCall
+/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Clone, Debug, PartialEq)]
+pub struct ImportCall {
+    arg: Box<Expression>,
+}
+
+impl ImportCall {
+    /// Creates a new `ImportCall` AST node.
+    pub fn new<A>(arg: A) -> Self
+    where
+        A: Into<Expression>,
+    {
+        Self {
+            arg: Box::new(arg.into()),
+        }
+    }
+
+    /// Retrieves the single argument of the import call.
+    #[must_use]
+    pub const fn argument(&self) -> &Expression {
+        &self.arg
+    }
+}
+
+impl ToInternedString for ImportCall {
+    #[inline]
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("import({})", self.arg.to_interned_string(interner))
+    }
+}
+
+impl From<ImportCall> for Expression {
+    #[inline]
+    fn from(call: ImportCall) -> Self {
+        Self::ImportCall(call)
+    }
+}
+
+impl VisitWith for ImportCall {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        visitor.visit_expression(&self.arg)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        visitor.visit_expression_mut(&mut self.arg)
+    }
+}

boa_ast/src/expression/literal/object.rs

@@ -256,16 +256,32 @@ impl ToIndentedString for ObjectLiteral {
                             MethodDefinition::Get(expression)
                             | MethodDefinition::Set(expression)
                             | MethodDefinition::Ordinary(expression) => {
-                                block_to_string(expression.body(), interner, indent_n + 1)
+                                block_to_string(
+                                    expression.body().statements(),
+                                    interner,
+                                    indent_n + 1,
+                                )
                             }
                             MethodDefinition::Generator(expression) => {
-                                block_to_string(expression.body(), interner, indent_n + 1)
+                                block_to_string(
+                                    expression.body().statements(),
+                                    interner,
+                                    indent_n + 1,
+                                )
                             }
                             MethodDefinition::AsyncGenerator(expression) => {
-                                block_to_string(expression.body(), interner, indent_n + 1)
+                                block_to_string(
+                                    expression.body().statements(),
+                                    interner,
+                                    indent_n + 1,
+                                )
                             }
                             MethodDefinition::Async(expression) => {
-                                block_to_string(expression.body(), interner, indent_n + 1)
+                                block_to_string(
+                                    expression.body().statements(),
+                                    interner,
+                                    indent_n + 1,
+                                )
                             }
                         },
                     )

boa_ast/src/expression/mod.rs

@@ -33,7 +33,7 @@ mod tagged_template;
 mod r#yield;
 
 use crate::visitor::{VisitWith, Visitor, VisitorMut};
-pub use call::{Call, SuperCall};
+pub use call::{Call, ImportCall, SuperCall};
 pub use identifier::{Identifier, RESERVED_IDENTIFIERS_STRICT};
 pub use new::New;
 pub use optional::{Optional, OptionalOperation, OptionalOperationKind};
@@ -121,10 +121,12 @@ pub enum Expression {
     /// See [`SuperCall`].
     SuperCall(SuperCall),
 
+    /// See [`ImportCall`].
+    ImportCall(ImportCall),
+
     /// See [`Optional`].
     Optional(Optional),
 
-    // TODO: Import calls
     /// See [`TaggedTemplate`].
     TaggedTemplate(TaggedTemplate),
 
@@ -192,6 +194,7 @@ impl Expression {
             Self::New(new) => new.to_interned_string(interner),
             Self::Call(call) => call.to_interned_string(interner),
             Self::SuperCall(supc) => supc.to_interned_string(interner),
+            Self::ImportCall(impc) => impc.to_interned_string(interner),
             Self::Optional(opt) => opt.to_interned_string(interner),
             Self::NewTarget => "new.target".to_owned(),
             Self::TaggedTemplate(tag) => tag.to_interned_string(interner),
@@ -300,6 +303,7 @@ impl VisitWith for Expression {
             Self::New(n) => visitor.visit_new(n),
             Self::Call(c) => visitor.visit_call(c),
             Self::SuperCall(sc) => visitor.visit_super_call(sc),
+            Self::ImportCall(ic) => visitor.visit_import_call(ic),
             Self::Optional(opt) => visitor.visit_optional(opt),
             Self::TaggedTemplate(tt) => visitor.visit_tagged_template(tt),
             Self::Assign(a) => visitor.visit_assign(a),
@@ -341,6 +345,7 @@ impl VisitWith for Expression {
             Self::New(n) => visitor.visit_new_mut(n),
             Self::Call(c) => visitor.visit_call_mut(c),
             Self::SuperCall(sc) => visitor.visit_super_call_mut(sc),
+            Self::ImportCall(ic) => visitor.visit_import_call_mut(ic),
             Self::Optional(opt) => visitor.visit_optional_mut(opt),
             Self::TaggedTemplate(tt) => visitor.visit_tagged_template_mut(tt),
             Self::Assign(a) => visitor.visit_assign_mut(a),

boa_ast/src/function/arrow_function.rs

@@ -2,12 +2,12 @@ use crate::try_break;
 use crate::visitor::{VisitWith, Visitor, VisitorMut};
 use crate::{
     expression::{Expression, Identifier},
-    join_nodes, StatementList,
+    join_nodes,
 };
 use boa_interner::{Interner, ToIndentedString};
 use core::ops::ControlFlow;
 
-use super::FormalParameterList;
+use super::{FormalParameterList, FunctionBody};
 
 /// An arrow function expression, as defined by the [spec].
 ///
@@ -24,7 +24,7 @@ use super::FormalParameterList;
 pub struct ArrowFunction {
     name: Option<Identifier>,
     parameters: FormalParameterList,
-    body: StatementList,
+    body: FunctionBody,
 }
 
 impl ArrowFunction {
@@ -34,7 +34,7 @@ impl ArrowFunction {
     pub const fn new(
         name: Option<Identifier>,
         params: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
     ) -> Self {
         Self {
             name,
@@ -66,7 +66,7 @@ impl ArrowFunction {
     /// Gets the body of the arrow function.
     #[inline]
     #[must_use]
-    pub const fn body(&self) -> &StatementList {
+    pub const fn body(&self) -> &FunctionBody {
         &self.body
     }
 }
@@ -102,7 +102,7 @@ impl VisitWith for ArrowFunction {
             try_break!(visitor.visit_identifier(ident));
         }
         try_break!(visitor.visit_formal_parameter_list(&self.parameters));
-        visitor.visit_statement_list(&self.body)
+        visitor.visit_script(&self.body)
     }
 
     fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
@@ -113,6 +113,6 @@ impl VisitWith for ArrowFunction {
             try_break!(visitor.visit_identifier_mut(ident));
         }
         try_break!(visitor.visit_formal_parameter_list_mut(&mut self.parameters));
-        visitor.visit_statement_list_mut(&mut self.body)
+        visitor.visit_script_mut(&mut self.body)
     }
 }

boa_ast/src/function/async_arrow_function.rs

@@ -1,11 +1,11 @@
 use std::ops::ControlFlow;
 
-use super::FormalParameterList;
+use super::{FormalParameterList, FunctionBody};
 use crate::try_break;
 use crate::visitor::{VisitWith, Visitor, VisitorMut};
 use crate::{
     expression::{Expression, Identifier},
-    join_nodes, StatementList,
+    join_nodes,
 };
 use boa_interner::{Interner, ToIndentedString};
 
@@ -24,7 +24,7 @@ use boa_interner::{Interner, ToIndentedString};
 pub struct AsyncArrowFunction {
     name: Option<Identifier>,
     parameters: FormalParameterList,
-    body: StatementList,
+    body: FunctionBody,
 }
 
 impl AsyncArrowFunction {
@@ -34,7 +34,7 @@ impl AsyncArrowFunction {
     pub const fn new(
         name: Option<Identifier>,
         parameters: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
     ) -> Self {
         Self {
             name,
@@ -66,7 +66,7 @@ impl AsyncArrowFunction {
     /// Gets the body of the arrow function.
     #[inline]
     #[must_use]
-    pub const fn body(&self) -> &StatementList {
+    pub const fn body(&self) -> &FunctionBody {
         &self.body
     }
 }
@@ -102,7 +102,7 @@ impl VisitWith for AsyncArrowFunction {
             try_break!(visitor.visit_identifier(ident));
         }
         try_break!(visitor.visit_formal_parameter_list(&self.parameters));
-        visitor.visit_statement_list(&self.body)
+        visitor.visit_script(&self.body)
     }
 
     fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
@@ -113,6 +113,6 @@ impl VisitWith for AsyncArrowFunction {
             try_break!(visitor.visit_identifier_mut(ident));
         }
         try_break!(visitor.visit_formal_parameter_list_mut(&mut self.parameters));
-        visitor.visit_statement_list_mut(&mut self.body)
+        visitor.visit_script_mut(&mut self.body)
     }
 }

boa_ast/src/function/async_function.rs

@@ -4,12 +4,12 @@ use crate::try_break;
 use crate::visitor::{VisitWith, Visitor, VisitorMut};
 use crate::{
     expression::{Expression, Identifier},
-    join_nodes, Declaration, StatementList,
+    join_nodes, Declaration,
 };
 use boa_interner::{Interner, ToIndentedString};
 use core::ops::ControlFlow;
 
-use super::FormalParameterList;
+use super::{FormalParameterList, FunctionBody};
 
 /// An async function definition, as defined by the [spec].
 ///
@@ -25,7 +25,7 @@ use super::FormalParameterList;
 pub struct AsyncFunction {
     name: Option<Identifier>,
     parameters: FormalParameterList,
-    body: StatementList,
+    body: FunctionBody,
     has_binding_identifier: bool,
 }
 
@@ -36,7 +36,7 @@ impl AsyncFunction {
     pub const fn new(
         name: Option<Identifier>,
         parameters: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
         has_binding_identifier: bool,
     ) -> Self {
         Self {
@@ -64,7 +64,7 @@ impl AsyncFunction {
     /// Gets the body of the function declaration.
     #[inline]
     #[must_use]
-    pub const fn body(&self) -> &StatementList {
+    pub const fn body(&self) -> &FunctionBody {
         &self.body
     }
 
@@ -122,7 +122,7 @@ impl VisitWith for AsyncFunction {
             try_break!(visitor.visit_identifier(ident));
         }
         try_break!(visitor.visit_formal_parameter_list(&self.parameters));
-        visitor.visit_statement_list(&self.body)
+        visitor.visit_script(&self.body)
     }
 
     fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
@@ -133,6 +133,6 @@ impl VisitWith for AsyncFunction {
             try_break!(visitor.visit_identifier_mut(ident));
         }
         try_break!(visitor.visit_formal_parameter_list_mut(&mut self.parameters));
-        visitor.visit_statement_list_mut(&mut self.body)
+        visitor.visit_script_mut(&mut self.body)
     }
 }

boa_ast/src/function/async_generator.rs

@@ -4,12 +4,12 @@ use crate::visitor::{VisitWith, Visitor, VisitorMut};
 use crate::{
     block_to_string,
     expression::{Expression, Identifier},
-    join_nodes, Declaration, StatementList,
+    join_nodes, Declaration,
 };
 use boa_interner::{Interner, ToIndentedString};
 use core::ops::ControlFlow;
 
-use super::FormalParameterList;
+use super::{FormalParameterList, FunctionBody};
 
 /// An async generator definition, as defined by the [spec].
 ///
@@ -24,7 +24,7 @@ use super::FormalParameterList;
 pub struct AsyncGenerator {
     name: Option<Identifier>,
     parameters: FormalParameterList,
-    body: StatementList,
+    body: FunctionBody,
     has_binding_identifier: bool,
 }
 
@@ -35,7 +35,7 @@ impl AsyncGenerator {
     pub const fn new(
         name: Option<Identifier>,
         parameters: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
         has_binding_identifier: bool,
     ) -> Self {
         Self {
@@ -63,7 +63,7 @@ impl AsyncGenerator {
     /// Gets the body of the async generator expression
     #[inline]
     #[must_use]
-    pub const fn body(&self) -> &StatementList {
+    pub const fn body(&self) -> &FunctionBody {
         &self.body
     }
 
@@ -84,7 +84,7 @@ impl ToIndentedString for AsyncGenerator {
         buf.push_str(&format!(
             "({}) {}",
             join_nodes(interner, self.parameters.as_ref()),
-            block_to_string(&self.body, interner, indentation)
+            block_to_string(self.body.statements(), interner, indentation)
         ));
 
         buf
@@ -114,7 +114,7 @@ impl VisitWith for AsyncGenerator {
             try_break!(visitor.visit_identifier(ident));
         }
         try_break!(visitor.visit_formal_parameter_list(&self.parameters));
-        visitor.visit_statement_list(&self.body)
+        visitor.visit_script(&self.body)
     }
 
     fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
@@ -125,6 +125,6 @@ impl VisitWith for AsyncGenerator {
             try_break!(visitor.visit_identifier_mut(ident));
         }
         try_break!(visitor.visit_formal_parameter_list_mut(&mut self.parameters));
-        visitor.visit_statement_list_mut(&mut self.body)
+        visitor.visit_script_mut(&mut self.body)
     }
 }

boa_ast/src/function/class.rs

@@ -6,7 +6,7 @@ use crate::{
     property::{MethodDefinition, PropertyName},
     try_break,
     visitor::{VisitWith, Visitor, VisitorMut},
-    Declaration, StatementList, ToStringEscaped,
+    Declaration, ToStringEscaped,
 };
 use boa_interner::{Interner, Sym, ToIndentedString, ToInternedString};
 use core::ops::ControlFlow;
@@ -121,7 +121,7 @@ impl ToIndentedString for Class {
             buf.push_str(&format!(
                 "{indentation}constructor({}) {}\n",
                 join_nodes(interner, expr.parameters().as_ref()),
-                block_to_string(expr.body(), interner, indent_n + 1)
+                block_to_string(expr.body().statements(), interner, indent_n + 1)
             ));
         }
         for element in self.elements.iter() {
@@ -155,16 +155,16 @@ impl ToIndentedString for Class {
                             MethodDefinition::Get(expr)
                             | MethodDefinition::Set(expr)
                             | MethodDefinition::Ordinary(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Generator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::AsyncGenerator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Async(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                         },
                     )
@@ -198,16 +198,16 @@ impl ToIndentedString for Class {
                             MethodDefinition::Get(expr)
                             | MethodDefinition::Set(expr)
                             | MethodDefinition::Ordinary(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Generator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::AsyncGenerator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Async(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                         },
                     )
@@ -268,16 +268,16 @@ impl ToIndentedString for Class {
                             MethodDefinition::Get(expr)
                             | MethodDefinition::Set(expr)
                             | MethodDefinition::Ordinary(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Generator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::AsyncGenerator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Async(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                         },
                     )
@@ -311,16 +311,16 @@ impl ToIndentedString for Class {
                             MethodDefinition::Get(expr)
                             | MethodDefinition::Set(expr)
                             | MethodDefinition::Ordinary(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Generator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::AsyncGenerator(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                             MethodDefinition::Async(expr) => {
-                                block_to_string(expr.body(), interner, indent_n + 1)
+                                block_to_string(expr.body().statements(), interner, indent_n + 1)
                             }
                         },
                     )
@@ -355,10 +355,10 @@ impl ToIndentedString for Class {
                         )
                     }
                 },
-                ClassElement::StaticBlock(statement_list) => {
+                ClassElement::StaticBlock(body) => {
                     format!(
                         "{indentation}static {}\n",
-                        block_to_string(statement_list, interner, indent_n + 1)
+                        block_to_string(body.statements(), interner, indent_n + 1)
                     )
                 }
             });
@@ -420,6 +420,13 @@ impl VisitWith for Class {
     }
 }
 
+/// The body of a class' static block, as defined by the [spec].
+///
+/// Just an alias for [`Script`](crate::Script), since it has the same exact semantics.
+///
+/// [spec]: https://tc39.es/ecma262/#prod-ClassStaticBlockBody
+type StaticBlockBody = crate::Script;
+
 /// An element that can be within a [`Class`], as defined by the [spec].
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ClassElement
@@ -454,7 +461,7 @@ pub enum ClassElement {
     PrivateStaticFieldDefinition(PrivateName, Option<Expression>),
 
     /// A static block, where a class can have initialization logic for its static fields.
-    StaticBlock(StatementList),
+    StaticBlock(StaticBlockBody),
 }
 
 impl VisitWith for ClassElement {
@@ -489,7 +496,7 @@ impl VisitWith for ClassElement {
                     ControlFlow::Continue(())
                 }
             }
-            Self::StaticBlock(sl) => visitor.visit_statement_list(sl),
+            Self::StaticBlock(sl) => visitor.visit_script(sl),
         }
     }
 
@@ -524,7 +531,7 @@ impl VisitWith for ClassElement {
                     ControlFlow::Continue(())
                 }
             }
-            Self::StaticBlock(sl) => visitor.visit_statement_list_mut(sl),
+            Self::StaticBlock(sl) => visitor.visit_script_mut(sl),
         }
     }
 }

boa_ast/src/function/generator.rs

@@ -1,7 +1,7 @@
 use crate::{
     block_to_string,
     expression::{Expression, Identifier},
-    join_nodes, Declaration, StatementList,
+    join_nodes, Declaration,
 };
 use core::ops::ControlFlow;
 
@@ -9,7 +9,7 @@ use crate::try_break;
 use crate::visitor::{VisitWith, Visitor, VisitorMut};
 use boa_interner::{Interner, ToIndentedString};
 
-use super::FormalParameterList;
+use super::{FormalParameterList, FunctionBody};
 
 /// A generator definition, as defined by the [spec].
 ///
@@ -26,7 +26,7 @@ use super::FormalParameterList;
 pub struct Generator {
     name: Option<Identifier>,
     parameters: FormalParameterList,
-    body: StatementList,
+    body: FunctionBody,
     has_binding_identifier: bool,
 }
 
@@ -37,7 +37,7 @@ impl Generator {
     pub const fn new(
         name: Option<Identifier>,
         parameters: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
         has_binding_identifier: bool,
     ) -> Self {
         Self {
@@ -65,7 +65,7 @@ impl Generator {
     /// Gets the body of the generator declaration.
     #[inline]
     #[must_use]
-    pub const fn body(&self) -> &StatementList {
+    pub const fn body(&self) -> &FunctionBody {
         &self.body
     }
 
@@ -86,7 +86,7 @@ impl ToIndentedString for Generator {
         buf.push_str(&format!(
             "({}) {}",
             join_nodes(interner, self.parameters.as_ref()),
-            block_to_string(&self.body, interner, indentation)
+            block_to_string(self.body.statements(), interner, indentation)
         ));
 
         buf
@@ -116,7 +116,7 @@ impl VisitWith for Generator {
             try_break!(visitor.visit_identifier(ident));
         }
         try_break!(visitor.visit_formal_parameter_list(&self.parameters));
-        visitor.visit_statement_list(&self.body)
+        visitor.visit_script(&self.body)
     }
 
     fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
@@ -127,6 +127,6 @@ impl VisitWith for Generator {
             try_break!(visitor.visit_identifier_mut(ident));
         }
         try_break!(visitor.visit_formal_parameter_list_mut(&mut self.parameters));
-        visitor.visit_statement_list_mut(&mut self.body)
+        visitor.visit_script_mut(&mut self.body)
     }
 }

boa_ast/src/function/mod.rs

@@ -38,9 +38,9 @@ use core::ops::ControlFlow;
 pub use generator::Generator;
 pub use parameters::{FormalParameter, FormalParameterList, FormalParameterListFlags};
 
-use crate::try_break;
 use crate::visitor::{VisitWith, Visitor, VisitorMut};
-use crate::{block_to_string, join_nodes, StatementList};
+use crate::{block_to_string, join_nodes};
+use crate::{try_break, Script};
 use boa_interner::{Interner, ToIndentedString};
 
 use super::expression::{Expression, Identifier};
@@ -62,7 +62,7 @@ use super::Declaration;
 pub struct Function {
     name: Option<Identifier>,
     parameters: FormalParameterList,
-    body: StatementList,
+    body: FunctionBody,
     has_binding_identifier: bool,
 }
 
@@ -73,7 +73,7 @@ impl Function {
     pub const fn new(
         name: Option<Identifier>,
         parameters: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
     ) -> Self {
         Self {
             name,
@@ -89,7 +89,7 @@ impl Function {
     pub const fn new_with_binding_identifier(
         name: Option<Identifier>,
         parameters: FormalParameterList,
-        body: StatementList,
+        body: FunctionBody,
         has_binding_identifier: bool,
     ) -> Self {
         Self {
@@ -117,7 +117,7 @@ impl Function {
     /// Gets the body of the function declaration.
     #[inline]
     #[must_use]
-    pub const fn body(&self) -> &StatementList {
+    pub const fn body(&self) -> &FunctionBody {
         &self.body
     }
 
@@ -138,7 +138,7 @@ impl ToIndentedString for Function {
         buf.push_str(&format!(
             "({}) {}",
             join_nodes(interner, self.parameters.as_ref()),
-            block_to_string(&self.body, interner, indentation)
+            block_to_string(self.body.statements(), interner, indentation)
         ));
 
         buf
@@ -168,7 +168,7 @@ impl VisitWith for Function {
             try_break!(visitor.visit_identifier(ident));
         }
         try_break!(visitor.visit_formal_parameter_list(&self.parameters));
-        visitor.visit_statement_list(&self.body)
+        visitor.visit_script(&self.body)
     }
 
     fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
@@ -179,6 +179,17 @@ impl VisitWith for Function {
             try_break!(visitor.visit_identifier_mut(ident));
         }
         try_break!(visitor.visit_formal_parameter_list_mut(&mut self.parameters));
-        visitor.visit_statement_list_mut(&mut self.body)
+        visitor.visit_script_mut(&mut self.body)
     }
 }
+
+/// A Function body.
+///
+/// Since [`Script`] and `FunctionBody` has the same semantics, this is currently
+/// only an alias of the former.
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///
+/// [spec]: https://tc39.es/ecma262/#prod-FunctionBody
+pub type FunctionBody = Script;

boa_ast/src/lib.rs

@@ -75,15 +75,16 @@
     clippy::option_if_let_else
 )]
 
+mod module_item_list;
 mod position;
 mod punctuator;
+mod source;
 mod statement_list;
 
 pub mod declaration;
 pub mod expression;
 pub mod function;
 pub mod keyword;
-pub mod module_item_list;
 pub mod operations;
 pub mod pattern;
 pub mod property;
@@ -99,6 +100,7 @@ pub use self::{
     module_item_list::{ModuleItem, ModuleItemList},
     position::{Position, Span},
     punctuator::Punctuator,
+    source::{Module, Script},
     statement::Statement,
     statement_list::{StatementList, StatementListItem},
 };

boa_ast/src/module_item_list/mod.rs

@@ -31,7 +31,8 @@ use crate::{
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ModuleItemList
-#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct ModuleItemList {
     items: Box<[ModuleItem]>,
 }
@@ -462,7 +463,8 @@ impl VisitWith for ModuleItemList {
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-ModuleItem
-#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ModuleItem {
     /// See [`ImportDeclaration`].
     ImportDeclaration(ImportDeclaration),

boa_ast/src/operations.rs

@@ -9,7 +9,9 @@ use boa_interner::{Interner, Sym};
 use rustc_hash::FxHashSet;
 
 use crate::{
-    declaration::{Binding, ExportDeclaration, ImportDeclaration, VarDeclaration, Variable},
+    declaration::{
+        Binding, ExportDeclaration, ImportDeclaration, LexicalDeclaration, VarDeclaration, Variable,
+    },
     expression::{
         access::{PrivatePropertyAccess, SuperPropertyAccess},
         operator::BinaryInPrivate,
@@ -26,7 +28,7 @@ use crate::{
     },
     try_break,
     visitor::{NodeRef, VisitWith, Visitor},
-    Declaration, Expression, ModuleItem, Statement, StatementList, StatementListItem,
+    Declaration, Expression, ModuleItem, Script, Statement, StatementList, StatementListItem,
 };
 
 /// Represents all the possible symbols searched for by the [`Contains`][contains] operation.
@@ -451,63 +453,101 @@ struct LexicallyDeclaredNamesVisitor<'a, T: IdentList>(&'a mut T);
 impl<'ast, T: IdentList> Visitor<'ast> for LexicallyDeclaredNamesVisitor<'_, T> {
     type BreakTy = Infallible;
 
+    fn visit_script(&mut self, node: &'ast Script) -> ControlFlow<Self::BreakTy> {
+        top_level_lexicals(node.statements(), self.0);
+        ControlFlow::Continue(())
+    }
+
+    fn visit_module_item(&mut self, node: &'ast ModuleItem) -> ControlFlow<Self::BreakTy> {
+        match node {
+            // ModuleItem : ImportDeclaration
+            ModuleItem::ImportDeclaration(import) => {
+                // 1. Return the BoundNames of ImportDeclaration.
+                BoundNamesVisitor(self.0).visit_import_declaration(import)
+            }
+
+            // ModuleItem : ExportDeclaration
+            ModuleItem::ExportDeclaration(export) => {
+                // 1. If ExportDeclaration is export VariableStatement, return a new empty List.
+                if matches!(export, ExportDeclaration::VarStatement(_)) {
+                    ControlFlow::Continue(())
+                } else {
+                    // 2. Return the BoundNames of ExportDeclaration.
+                    BoundNamesVisitor(self.0).visit_export_declaration(export)
+                }
+            }
+
+            // ModuleItem : StatementListItem
+            ModuleItem::StatementListItem(item) => {
+                // 1. Return LexicallyDeclaredNames of StatementListItem.
+                self.visit_statement_list_item(item)
+            }
+        }
+    }
+
     fn visit_expression(&mut self, _: &'ast Expression) -> ControlFlow<Self::BreakTy> {
         ControlFlow::Continue(())
     }
+
     fn visit_statement(&mut self, node: &'ast Statement) -> ControlFlow<Self::BreakTy> {
         if let Statement::Labelled(labelled) = node {
             return self.visit_labelled(labelled);
         }
         ControlFlow::Continue(())
     }
+
     fn visit_declaration(&mut self, node: &'ast Declaration) -> ControlFlow<Self::BreakTy> {
         BoundNamesVisitor(self.0).visit_declaration(node)
     }
+
     fn visit_labelled_item(&mut self, node: &'ast LabelledItem) -> ControlFlow<Self::BreakTy> {
         match node {
             LabelledItem::Function(f) => BoundNamesVisitor(self.0).visit_function(f),
             LabelledItem::Statement(_) => ControlFlow::Continue(()),
         }
     }
+
     fn visit_function(&mut self, node: &'ast Function) -> ControlFlow<Self::BreakTy> {
-        top_level_lexicals(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
+
     fn visit_async_function(&mut self, node: &'ast AsyncFunction) -> ControlFlow<Self::BreakTy> {
-        top_level_lexicals(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
+
     fn visit_generator(&mut self, node: &'ast Generator) -> ControlFlow<Self::BreakTy> {
-        top_level_lexicals(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
+
     fn visit_async_generator(&mut self, node: &'ast AsyncGenerator) -> ControlFlow<Self::BreakTy> {
-        top_level_lexicals(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
+
     fn visit_arrow_function(&mut self, node: &'ast ArrowFunction) -> ControlFlow<Self::BreakTy> {
-        top_level_lexicals(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
+
     fn visit_async_arrow_function(
         &mut self,
         node: &'ast AsyncArrowFunction,
     ) -> ControlFlow<Self::BreakTy> {
-        top_level_lexicals(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
+
     fn visit_class_element(&mut self, node: &'ast ClassElement) -> ControlFlow<Self::BreakTy> {
-        if let ClassElement::StaticBlock(stmts) = node {
+        if let ClassElement::StaticBlock(body) = node {
-            top_level_lexicals(stmts, self.0);
+            self.visit_script(body);
         }
         ControlFlow::Continue(())
     }
+
     fn visit_import_declaration(
         &mut self,
         node: &'ast ImportDeclaration,
     ) -> ControlFlow<Self::BreakTy> {
         BoundNamesVisitor(self.0).visit_import_declaration(node)
     }
+
     fn visit_export_declaration(
         &mut self,
         node: &'ast ExportDeclaration,
@@ -517,10 +557,6 @@ impl<'ast, T: IdentList> Visitor<'ast> for LexicallyDeclaredNamesVisitor<'_, T>
         }
         BoundNamesVisitor(self.0).visit_export_declaration(node)
     }
-
-    // TODO:  ScriptBody : StatementList
-    // 1. Return TopLevelLexicallyDeclaredNames of StatementList.
-    // But we don't have that node yet. In the meantime, use `top_level_lexically_declared_names` directly.
 }
 
 /// Returns a list with the lexical bindings of a node, which may contain duplicates.
@@ -562,6 +598,34 @@ struct VarDeclaredNamesVisitor<'a>(&'a mut FxHashSet<Identifier>);
 impl<'ast> Visitor<'ast> for VarDeclaredNamesVisitor<'_> {
     type BreakTy = Infallible;
 
+    fn visit_script(&mut self, node: &'ast Script) -> ControlFlow<Self::BreakTy> {
+        top_level_vars(node.statements(), self.0);
+        ControlFlow::Continue(())
+    }
+
+    fn visit_module_item(&mut self, node: &'ast ModuleItem) -> ControlFlow<Self::BreakTy> {
+        match node {
+            // ModuleItem : ImportDeclaration
+            ModuleItem::ImportDeclaration(_) => {
+                // 1. Return a new empty List.
+                ControlFlow::Continue(())
+            }
+
+            // ModuleItem : ExportDeclaration
+            ModuleItem::ExportDeclaration(export) => {
+                // 1. If ExportDeclaration is export VariableStatement, return BoundNames of ExportDeclaration.
+                if let ExportDeclaration::VarStatement(var) = export {
+                    BoundNamesVisitor(self.0).visit_var_declaration(var)
+                } else {
+                    // 2. Return a new empty List.
+                    ControlFlow::Continue(())
+                }
+            }
+
+            ModuleItem::StatementListItem(item) => self.visit_statement_list_item(item),
+        }
+    }
+
     fn visit_statement(&mut self, node: &'ast Statement) -> ControlFlow<Self::BreakTy> {
         match node {
             Statement::Empty
@@ -682,28 +746,24 @@ impl<'ast> Visitor<'ast> for VarDeclaredNamesVisitor<'_> {
     }
 
     fn visit_function(&mut self, node: &'ast Function) -> ControlFlow<Self::BreakTy> {
-        top_level_vars(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
 
     fn visit_async_function(&mut self, node: &'ast AsyncFunction) -> ControlFlow<Self::BreakTy> {
-        top_level_vars(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
 
     fn visit_generator(&mut self, node: &'ast Generator) -> ControlFlow<Self::BreakTy> {
-        top_level_vars(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
 
     fn visit_async_generator(&mut self, node: &'ast AsyncGenerator) -> ControlFlow<Self::BreakTy> {
-        top_level_vars(node.body(), self.0);
+        self.visit_script(node.body())
-        ControlFlow::Continue(())
     }
 
     fn visit_class_element(&mut self, node: &'ast ClassElement) -> ControlFlow<Self::BreakTy> {
-        if let ClassElement::StaticBlock(stmts) = node {
+        if let ClassElement::StaticBlock(body) = node {
-            top_level_vars(stmts, self.0);
+            self.visit_script(body);
         }
         node.visit_with(self)
     }
@@ -726,10 +786,6 @@ impl<'ast> Visitor<'ast> for VarDeclaredNamesVisitor<'_> {
             _ => ControlFlow::Continue(()),
         }
     }
-
-    // TODO:  ScriptBody : StatementList
-    // 1. Return TopLevelVarDeclaredNames of StatementList.
-    // But we don't have that node yet. In the meantime, use `top_level_var_declared_names` directly.
 }
 
 /// Returns a set with the var bindings of a node, with no duplicates.
@@ -748,6 +804,10 @@ where
 }
 
 /// Utility function that collects the top level lexicals of a statement list into `names`.
+///
+/// This is equivalent to the [`TopLevelLexicallyDeclaredNames`][spec] syntax operation in the spec.
+///
+/// [spec]: https://tc39.es/ecma262/#sec-static-semantics-toplevellexicallydeclarednames
 fn top_level_lexicals<T: IdentList>(stmts: &StatementList, names: &mut T) {
     for stmt in stmts.statements() {
         if let StatementListItem::Declaration(decl) = stmt {
@@ -770,20 +830,11 @@ fn top_level_lexicals<T: IdentList>(stmts: &StatementList, names: &mut T) {
     }
 }
 
-/// Returns a list with the lexical bindings of a top-level statement list, which may contain duplicates.
+/// Utility function that collects the top level vars of a statement list into `names`.
 ///
-/// This is equivalent to the [`TopLevelLexicallyDeclaredNames`][spec] syntax operation in the spec.
+/// This is equivalent to the [`TopLevelVarDeclaredNames`][spec] syntax operation in the spec.
 ///
-/// [spec]: https://tc39.es/ecma262/#sec-static-semantics-toplevellexicallydeclarednames
+/// [spec]: https://tc39.es/ecma262/#sec-static-semantics-toplevelvardeclarednames
-#[must_use]
-#[inline]
-pub fn top_level_lexically_declared_names(stmts: &StatementList) -> Vec<Identifier> {
-    let mut names = Vec::new();
-    top_level_lexicals(stmts, &mut names);
-    names
-}
-
-/// Utility function that collects the top level vars of a statement list into `names`.
 fn top_level_vars(stmts: &StatementList, names: &mut FxHashSet<Identifier>) {
     for stmt in stmts.statements() {
         match stmt {
@@ -826,19 +877,6 @@ fn top_level_vars(stmts: &StatementList, names: &mut FxHashSet<Identifier>) {
     }
 }
 
-/// Returns a list with the var bindings of a top-level statement list, with no duplicates.
-///
-/// This is equivalent to the [`TopLevelVarDeclaredNames`][spec] syntax operation in the spec.
-///
-/// [spec]: https://tc39.es/ecma262/#sec-static-semantics-toplevelvardeclarednames
-#[must_use]
-#[inline]
-pub fn top_level_var_declared_names(stmts: &StatementList) -> FxHashSet<Identifier> {
-    let mut names = FxHashSet::default();
-    top_level_vars(stmts, &mut names);
-    names
-}
-
 /// Returns `true` if all private identifiers in a node are valid.
 ///
 /// This is equivalent to the [`AllPrivateIdentifiersValid`][spec] syntax operation in the spec.
@@ -1319,13 +1357,69 @@ where
     node.visit_with(&mut visitor).is_break()
 }
 
+/// The type of a lexically scoped declaration.
+#[derive(Clone, Debug)]
+pub enum LexicallyScopedDeclaration {
+    /// See [`LexicalDeclaration`]
+    LexicalDeclaration(LexicalDeclaration),
+
+    /// See [`Function`]
+    Function(Function),
+
+    /// See [`Generator`]
+    Generator(Generator),
+
+    /// See [`AsyncFunction`]
+    AsyncFunction(AsyncFunction),
+
+    /// See [`AsyncGenerator`]
+    AsyncGenerator(AsyncGenerator),
+
+    /// See [`Class`]
+    Class(Class),
+
+    /// A default assignment expression as an export declaration.
+    ///
+    /// Only valid inside module exports.
+    AssignmentExpression(Expression),
+}
+
+impl LexicallyScopedDeclaration {
+    /// Return the bound names of the declaration.
+    #[must_use]
+    pub fn bound_names(&self) -> Vec<Identifier> {
+        match self {
+            Self::LexicalDeclaration(v) => bound_names(v),
+            Self::Function(f) => bound_names(f),
+            Self::Generator(g) => bound_names(g),
+            Self::AsyncFunction(f) => bound_names(f),
+            Self::AsyncGenerator(g) => bound_names(g),
+            Self::Class(cl) => bound_names(cl),
+            Self::AssignmentExpression(expr) => bound_names(expr),
+        }
+    }
+}
+
+impl From<Declaration> for LexicallyScopedDeclaration {
+    fn from(value: Declaration) -> Self {
+        match value {
+            Declaration::Function(f) => Self::Function(f),
+            Declaration::Generator(g) => Self::Generator(g),
+            Declaration::AsyncFunction(af) => Self::AsyncFunction(af),
+            Declaration::AsyncGenerator(ag) => Self::AsyncGenerator(ag),
+            Declaration::Class(c) => Self::Class(c),
+            Declaration::Lexical(lex) => Self::LexicalDeclaration(lex),
+        }
+    }
+}
+
 /// Returns a list of lexically scoped declarations of the given node.
 ///
 /// This is equivalent to the [`LexicallyScopedDeclarations`][spec] syntax operation in the spec.
 ///
 /// [spec]: https://tc39.es/ecma262/#sec-static-semantics-lexicallyscopeddeclarations
 #[must_use]
-pub fn lexically_scoped_declarations<'a, N>(node: &'a N) -> Vec<Declaration>
+pub fn lexically_scoped_declarations<'a, N>(node: &'a N) -> Vec<LexicallyScopedDeclaration>
 where
     &'a N: Into<NodeRef<'a>>,
 {
@@ -1336,22 +1430,91 @@ where
 
 /// The [`Visitor`] used to obtain the lexically scoped declarations of a node.
 #[derive(Debug)]
-struct LexicallyScopedDeclarationsVisitor<'a>(&'a mut Vec<Declaration>);
+struct LexicallyScopedDeclarationsVisitor<'a>(&'a mut Vec<LexicallyScopedDeclaration>);
 
 impl<'ast> Visitor<'ast> for LexicallyScopedDeclarationsVisitor<'_> {
     type BreakTy = Infallible;
 
+    // ScriptBody : StatementList
+    fn visit_script(&mut self, node: &'ast Script) -> ControlFlow<Self::BreakTy> {
+        // 1. Return TopLevelLexicallyScopedDeclarations of StatementList.
+        TopLevelLexicallyScopedDeclarationsVisitor(self.0).visit_statement_list(node.statements())
+    }
+
+    fn visit_export_declaration(
+        &mut self,
+        node: &'ast ExportDeclaration,
+    ) -> ControlFlow<Self::BreakTy> {
+        let decl = match node {
+            // ExportDeclaration :
+            // export ExportFromClause FromClause ;
+            // export NamedExports ;
+            // export VariableStatement
+            ExportDeclaration::ReExport { .. }
+            | ExportDeclaration::List(_)
+            | ExportDeclaration::VarStatement(_) => {
+                //     1. Return a new empty List.
+                return ControlFlow::Continue(());
+            }
+
+            // ExportDeclaration : export Declaration
+            ExportDeclaration::Declaration(decl) => {
+                // 1. Return a List whose sole element is DeclarationPart of Declaration.
+                decl.clone().into()
+            }
+
+            // ExportDeclaration : export default HoistableDeclaration
+            // 1. Return a List whose sole element is DeclarationPart of HoistableDeclaration.
+            ExportDeclaration::DefaultFunction(f) => {
+                LexicallyScopedDeclaration::Function(f.clone())
+            }
+            ExportDeclaration::DefaultGenerator(g) => {
+                LexicallyScopedDeclaration::Generator(g.clone())
+            }
+            ExportDeclaration::DefaultAsyncFunction(af) => {
+                LexicallyScopedDeclaration::AsyncFunction(af.clone())
+            }
+            ExportDeclaration::DefaultAsyncGenerator(ag) => {
+                LexicallyScopedDeclaration::AsyncGenerator(ag.clone())
+            }
+
+            // ExportDeclaration : export default ClassDeclaration
+            ExportDeclaration::DefaultClassDeclaration(c) => {
+                // 1. Return a List whose sole element is ClassDeclaration.
+                LexicallyScopedDeclaration::Class(c.clone())
+            }
+
+            // ExportDeclaration : export default AssignmentExpression ;
+            ExportDeclaration::DefaultAssignmentExpression(expr) => {
+                // 1. Return a List whose sole element is this ExportDeclaration.
+                LexicallyScopedDeclaration::AssignmentExpression(expr.clone())
+            }
+        };
+
+        self.0.push(decl);
+
+        ControlFlow::Continue(())
+    }
+
     fn visit_statement_list_item(
         &mut self,
         node: &'ast StatementListItem,
     ) -> ControlFlow<Self::BreakTy> {
         match node {
+            // StatementListItem : Statement
             StatementListItem::Statement(Statement::Labelled(labelled)) => {
+                // 1. If Statement is Statement : LabelledStatement , return LexicallyScopedDeclarations of LabelledStatement.
                 self.visit_labelled(labelled)
             }
-            StatementListItem::Statement(_) => ControlFlow::Continue(()),
+            StatementListItem::Statement(_) => {
+                // 2. Return a new empty List.
+                ControlFlow::Continue(())
+            }
+
+            // StatementListItem : Declaration
             StatementListItem::Declaration(declaration) => {
-                self.0.push(declaration.clone());
+                // 1. Return a List whose sole element is DeclarationPart of Declaration.
+                self.0.push(declaration.clone().into());
                 ControlFlow::Continue(())
             }
         }
@@ -1359,46 +1522,77 @@ impl<'ast> Visitor<'ast> for LexicallyScopedDeclarationsVisitor<'_> {
 
     fn visit_labelled_item(&mut self, node: &'ast LabelledItem) -> ControlFlow<Self::BreakTy> {
         match node {
+            // LabelledItem : FunctionDeclaration
             LabelledItem::Function(f) => {
-                self.0.push(f.clone().into());
+                // 1. Return « FunctionDeclaration ».
-                ControlFlow::Continue(())
+                self.0.push(LexicallyScopedDeclaration::Function(f.clone()));
             }
-            LabelledItem::Statement(_) => ControlFlow::Continue(()),
+
+            // LabelledItem : Statement
+            LabelledItem::Statement(_) => {
+                // 1. Return a new empty List.
             }
         }
+        ControlFlow::Continue(())
+    }
 
     fn visit_module_item(&mut self, node: &'ast ModuleItem) -> ControlFlow<Self::BreakTy> {
         match node {
             ModuleItem::StatementListItem(item) => self.visit_statement_list_item(item),
-            ModuleItem::ExportDeclaration(ExportDeclaration::Declaration(declaration)) => {
+            ModuleItem::ExportDeclaration(export) => self.visit_export_declaration(export),
-                self.0.push(declaration.clone());
+
+            // ModuleItem : ImportDeclaration
+            ModuleItem::ImportDeclaration(_) => {
+                // 1. Return a new empty List.
                 ControlFlow::Continue(())
             }
-            ModuleItem::ExportDeclaration(ExportDeclaration::DefaultFunction(f)) => {
-                self.0.push(f.clone().into());
-                ControlFlow::Continue(())
         }
-            ModuleItem::ExportDeclaration(ExportDeclaration::DefaultGenerator(f)) => {
-                self.0.push(f.clone().into());
-                ControlFlow::Continue(())
     }
-            ModuleItem::ExportDeclaration(ExportDeclaration::DefaultAsyncFunction(f)) => {
-                self.0.push(f.clone().into());
-                ControlFlow::Continue(())
 }
-            ModuleItem::ExportDeclaration(ExportDeclaration::DefaultAsyncGenerator(f)) => {
+/// The [`Visitor`] used to obtain the top level lexically scoped declarations of a node.
-                self.0.push(f.clone().into());
+///
-                ControlFlow::Continue(())
+/// This is equivalent to the [`TopLevelLexicallyScopedDeclarations`][spec] syntax operation in the spec.
+///
+/// [spec]: https://tc39.es/ecma262/#sec-static-semantics-toplevellexicallyscopeddeclarations
+#[derive(Debug)]
+struct TopLevelLexicallyScopedDeclarationsVisitor<'a>(&'a mut Vec<LexicallyScopedDeclaration>);
+
+impl<'ast> Visitor<'ast> for TopLevelLexicallyScopedDeclarationsVisitor<'_> {
+    type BreakTy = Infallible;
+
+    fn visit_statement_list_item(
+        &mut self,
+        node: &'ast StatementListItem,
+    ) -> ControlFlow<Self::BreakTy> {
+        match node {
+            // StatementListItem : Declaration
+            StatementListItem::Declaration(d) => match d {
+                // 1. If Declaration is Declaration : HoistableDeclaration , then
+                Declaration::Function(_)
+                | Declaration::Generator(_)
+                | Declaration::AsyncFunction(_)
+                | Declaration::AsyncGenerator(_) => {
+                    // a. Return a new empty List.
                 }
-            ModuleItem::ExportDeclaration(ExportDeclaration::DefaultClassDeclaration(f)) => {
+
-                self.0.push(f.clone().into());
+                // 2. Return « Declaration ».
-                ControlFlow::Continue(())
+                Declaration::Class(cl) => {
+                    self.0.push(LexicallyScopedDeclaration::Class(cl.clone()));
                 }
-            ModuleItem::ImportDeclaration(_) | ModuleItem::ExportDeclaration(_) => {
+                Declaration::Lexical(lex) => {
-                ControlFlow::Continue(())
+                    self.0
+                        .push(LexicallyScopedDeclaration::LexicalDeclaration(lex.clone()));
                 }
+            },
+
+            // StatementListItem : Statement
+            StatementListItem::Statement(_) => {
+                // 1. Return a new empty List.
             }
         }
+
+        ControlFlow::Continue(())
+    }
 }
 
 /// The type of a var scoped declaration.
@@ -1456,6 +1650,12 @@ struct VarScopedDeclarationsVisitor<'a>(&'a mut Vec<VarScopedDeclaration>);
 impl<'ast> Visitor<'ast> for VarScopedDeclarationsVisitor<'_> {
     type BreakTy = Infallible;
 
+    // ScriptBody : StatementList
+    fn visit_script(&mut self, node: &'ast Script) -> ControlFlow<Self::BreakTy> {
+        // 1. Return TopLevelVarScopedDeclarations of StatementList.
+        TopLevelVarScopedDeclarationsVisitor(self.0).visit_statement_list(node.statements())
+    }
+
     fn visit_statement(&mut self, node: &'ast Statement) -> ControlFlow<Self::BreakTy> {
         match node {
             Statement::Block(s) => self.visit(s),
@@ -1590,29 +1790,31 @@ impl<'ast> Visitor<'ast> for VarScopedDeclarationsVisitor<'_> {
 
     fn visit_module_item(&mut self, node: &'ast ModuleItem) -> ControlFlow<Self::BreakTy> {
         match node {
-            ModuleItem::ExportDeclaration(ExportDeclaration::VarStatement(var)) => self.visit(var),
+            // ModuleItem : ExportDeclaration
-            ModuleItem::StatementListItem(item) => self.visit(item),
+            ModuleItem::ExportDeclaration(decl) => {
-            _ => ControlFlow::Continue(()),
+                if let ExportDeclaration::VarStatement(var) = decl {
+                    //     1. If ExportDeclaration is export VariableStatement, return VarScopedDeclarations of VariableStatement.
+                    self.visit_var_declaration(var);
                 }
+                // 2. Return a new empty List.
+            }
+            ModuleItem::StatementListItem(item) => {
+                self.visit_statement_list_item(item);
+            }
+            // ModuleItem : ImportDeclaration
+            ModuleItem::ImportDeclaration(_) => {
+                // 1. Return a new empty List.
+            }
+        }
+        ControlFlow::Continue(())
     }
 }
 
-/// Returns a list of top level var scoped declarations of the given node.
+/// The [`Visitor`] used to obtain the top level var scoped declarations of a node.
 ///
 /// This is equivalent to the [`TopLevelVarScopedDeclarations`][spec] syntax operation in the spec.
 ///
 /// [spec]: https://tc39.es/ecma262/#sec-static-semantics-toplevelvarscopeddeclarations
-#[must_use]
-pub fn top_level_var_scoped_declarations<'a, N>(node: &'a N) -> Vec<VarScopedDeclaration>
-where
-    &'a N: Into<NodeRef<'a>>,
-{
-    let mut declarations = Vec::new();
-    TopLevelVarScopedDeclarationsVisitor(&mut declarations).visit(node.into());
-    declarations
-}
-
-/// The [`Visitor`] used to obtain the top level var scoped declarations of a node.
 #[derive(Debug)]
 struct TopLevelVarScopedDeclarationsVisitor<'a>(&'a mut Vec<VarScopedDeclaration>);
 

boa_ast/src/source.rs

@@ -0,0 +1,111 @@
+use std::ops::ControlFlow;
+
+use boa_interner::ToIndentedString;
+
+use crate::{
+    visitor::{VisitWith, Visitor, VisitorMut},
+    ModuleItemList, StatementList,
+};
+
+/// A Script source.
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///
+/// [spec]: https://tc39.es/ecma262/#sec-scripts
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Script {
+    statements: StatementList,
+}
+
+impl Script {
+    /// Creates a new `ScriptNode`.
+    #[must_use]
+    pub const fn new(statements: StatementList) -> Self {
+        Self { statements }
+    }
+
+    /// Gets the list of statements of this `ScriptNode`.
+    #[must_use]
+    pub const fn statements(&self) -> &StatementList {
+        &self.statements
+    }
+
+    /// Gets a mutable reference to the list of statements of this `ScriptNode`.
+    pub fn statements_mut(&mut self) -> &mut StatementList {
+        &mut self.statements
+    }
+
+    /// Gets the strict mode.
+    #[inline]
+    #[must_use]
+    pub const fn strict(&self) -> bool {
+        self.statements.strict()
+    }
+}
+
+impl VisitWith for Script {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        self.statements.visit_with(visitor)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        self.statements.visit_with_mut(visitor)
+    }
+}
+
+impl ToIndentedString for Script {
+    fn to_indented_string(&self, interner: &boa_interner::Interner, indentation: usize) -> String {
+        self.statements.to_indented_string(interner, indentation)
+    }
+}
+
+/// A Module source.
+///
+/// More information:
+///  - [ECMAScript reference][spec]
+///
+/// [spec]: https://tc39.es/ecma262/#sec-modules
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Module {
+    items: ModuleItemList,
+}
+
+impl Module {
+    /// Creates a new `ModuleNode`.
+    #[must_use]
+    pub const fn new(items: ModuleItemList) -> Self {
+        Self { items }
+    }
+
+    /// Gets the list of itemos of this `ModuleNode`.
+    #[must_use]
+    pub const fn items(&self) -> &ModuleItemList {
+        &self.items
+    }
+}
+
+impl VisitWith for Module {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        self.items.visit_with(visitor)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        self.items.visit_with_mut(visitor)
+    }
+}

boa_ast/src/statement_list.rs

@@ -8,6 +8,7 @@ use crate::{
 };
 use boa_interner::{Interner, ToIndentedString};
 use core::ops::ControlFlow;
+use std::ops::Deref;
 
 /// An item inside a [`StatementList`] Parse Node, as defined by the [spec].
 ///
@@ -149,6 +150,14 @@ impl From<Vec<StatementListItem>> for StatementList {
     }
 }
 
+impl Deref for StatementList {
+    type Target = [StatementListItem];
+
+    fn deref(&self) -> &Self::Target {
+        &self.statements
+    }
+}
+
 impl ToIndentedString for StatementList {
     fn to_indented_string(&self, interner: &Interner, indentation: usize) -> String {
         let mut buf = String::new();

boa_ast/src/visitor.rs

@@ -21,7 +21,7 @@ use crate::{
             assign::{Assign, AssignTarget},
             Binary, BinaryInPrivate, Conditional, Unary, Update,
         },
-        Await, Call, Expression, Identifier, New, Optional, OptionalOperation,
+        Await, Call, Expression, Identifier, ImportCall, New, Optional, OptionalOperation,
         OptionalOperationKind, Parenthesized, Spread, SuperCall, TaggedTemplate, Yield,
     },
     function::{
@@ -38,7 +38,7 @@ use crate::{
         Block, Case, Catch, Finally, If, Labelled, LabelledItem, Return, Statement, Switch, Throw,
         Try, With,
     },
-    ModuleItem, ModuleItemList, StatementList, StatementListItem,
+    Module, ModuleItem, ModuleItemList, Script, StatementList, StatementListItem,
 };
 use boa_interner::Sym;
 
@@ -118,6 +118,8 @@ macro_rules! node_ref {
 }
 
 node_ref! {
+    Script,
+    Module,
     StatementList,
     StatementListItem,
     Statement,
@@ -164,6 +166,7 @@ node_ref! {
     New,
     Call,
     SuperCall,
+    ImportCall,
     Optional,
     TaggedTemplate,
     Assign,
@@ -217,6 +220,8 @@ pub trait Visitor<'ast>: Sized {
     /// Type which will be propagated from the visitor if completing early.
     type BreakTy;
 
+    define_visit!(visit_script, Script);
+    define_visit!(visit_module, Module);
     define_visit!(visit_statement_list, StatementList);
     define_visit!(visit_statement_list_item, StatementListItem);
     define_visit!(visit_statement, Statement);
@@ -263,6 +268,7 @@ pub trait Visitor<'ast>: Sized {
     define_visit!(visit_new, New);
     define_visit!(visit_call, Call);
     define_visit!(visit_super_call, SuperCall);
+    define_visit!(visit_import_call, ImportCall);
     define_visit!(visit_optional, Optional);
     define_visit!(visit_tagged_template, TaggedTemplate);
     define_visit!(visit_assign, Assign);
@@ -313,6 +319,8 @@ pub trait Visitor<'ast>: Sized {
     fn visit<N: Into<NodeRef<'ast>>>(&mut self, node: N) -> ControlFlow<Self::BreakTy> {
         let node = node.into();
         match node {
+            NodeRef::Script(n) => self.visit_script(n),
+            NodeRef::Module(n) => self.visit_module(n),
             NodeRef::StatementList(n) => self.visit_statement_list(n),
             NodeRef::StatementListItem(n) => self.visit_statement_list_item(n),
             NodeRef::Statement(n) => self.visit_statement(n),
@@ -359,6 +367,7 @@ pub trait Visitor<'ast>: Sized {
             NodeRef::New(n) => self.visit_new(n),
             NodeRef::Call(n) => self.visit_call(n),
             NodeRef::SuperCall(n) => self.visit_super_call(n),
+            NodeRef::ImportCall(n) => self.visit_import_call(n),
             NodeRef::Optional(n) => self.visit_optional(n),
             NodeRef::TaggedTemplate(n) => self.visit_tagged_template(n),
             NodeRef::Assign(n) => self.visit_assign(n),
@@ -414,6 +423,8 @@ pub trait VisitorMut<'ast>: Sized {
     /// Type which will be propagated from the visitor if completing early.
     type BreakTy;
 
+    define_visit_mut!(visit_script_mut, Script);
+    define_visit_mut!(visit_module_mut, Module);
     define_visit_mut!(visit_statement_list_mut, StatementList);
     define_visit_mut!(visit_statement_list_item_mut, StatementListItem);
     define_visit_mut!(visit_statement_mut, Statement);
@@ -460,6 +471,7 @@ pub trait VisitorMut<'ast>: Sized {
     define_visit_mut!(visit_new_mut, New);
     define_visit_mut!(visit_call_mut, Call);
     define_visit_mut!(visit_super_call_mut, SuperCall);
+    define_visit_mut!(visit_import_call_mut, ImportCall);
     define_visit_mut!(visit_optional_mut, Optional);
     define_visit_mut!(visit_tagged_template_mut, TaggedTemplate);
     define_visit_mut!(visit_assign_mut, Assign);
@@ -510,6 +522,8 @@ pub trait VisitorMut<'ast>: Sized {
     fn visit<N: Into<NodeRefMut<'ast>>>(&mut self, node: N) -> ControlFlow<Self::BreakTy> {
         let node = node.into();
         match node {
+            NodeRefMut::Script(n) => self.visit_script_mut(n),
+            NodeRefMut::Module(n) => self.visit_module_mut(n),
             NodeRefMut::StatementList(n) => self.visit_statement_list_mut(n),
             NodeRefMut::StatementListItem(n) => self.visit_statement_list_item_mut(n),
             NodeRefMut::Statement(n) => self.visit_statement_mut(n),
@@ -556,6 +570,7 @@ pub trait VisitorMut<'ast>: Sized {
             NodeRefMut::New(n) => self.visit_new_mut(n),
             NodeRefMut::Call(n) => self.visit_call_mut(n),
             NodeRefMut::SuperCall(n) => self.visit_super_call_mut(n),
+            NodeRefMut::ImportCall(n) => self.visit_import_call_mut(n),
             NodeRefMut::Optional(n) => self.visit_optional_mut(n),
             NodeRefMut::TaggedTemplate(n) => self.visit_tagged_template_mut(n),
             NodeRefMut::Assign(n) => self.visit_assign_mut(n),

boa_cli/src/main.rs

@@ -59,10 +59,11 @@
 )]
 #![allow(clippy::option_if_let_else, clippy::redundant_pub_crate)]
 
+use boa_ast as _;
+
 mod debug;
 mod helper;
 
-use boa_ast::StatementList;
 use boa_engine::{
     builtins::promise::PromiseState,
     context::ContextBuilder,
@@ -70,15 +71,19 @@ use boa_engine::{
     module::{Module, ModuleLoader, SimpleModuleLoader},
     optimizer::OptimizerOptions,
     property::Attribute,
+    script::Script,
     vm::flowgraph::{Direction, Graph},
-    Context, JsNativeError, JsResult, Source,
+    Context, JsError, JsNativeError, JsResult, Source,
 };
 use boa_runtime::Console;
 use clap::{Parser, ValueEnum, ValueHint};
 use colored::{Color, Colorize};
 use debug::init_boa_debug_object;
 use rustyline::{config::Config, error::ReadlineError, EditMode, Editor};
-use std::{cell::RefCell, collections::VecDeque, fs::read, fs::OpenOptions, io, path::PathBuf};
+use std::{
+    cell::RefCell, collections::VecDeque, eprintln, fs::read, fs::OpenOptions, io, path::PathBuf,
+    println,
+};
 
 #[cfg(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"))]
 #[cfg_attr(
@@ -174,7 +179,7 @@ impl Opt {
     }
 }
 
-#[derive(Debug, Clone, ValueEnum)]
+#[derive(Debug, Copy, Clone, Default, ValueEnum)]
 enum DumpFormat {
     /// The different types of format available for dumping.
     // NOTE: This can easily support other formats just by
@@ -185,6 +190,7 @@ enum DumpFormat {
     // arg_enum! macro does not support it.
 
     // This is the default format that you get from std::fmt::Debug.
+    #[default]
     Debug,
 
     // This is a minified json format.
@@ -212,19 +218,6 @@ enum FlowgraphDirection {
     RightToLeft,
 }
 
-/// Parses the the token stream into an AST and returns it.
-///
-/// Returns a error of type String with a message,
-/// if the token stream has a parsing error.
-fn parse_tokens<S>(src: &S, context: &mut Context<'_>) -> Result<StatementList, String>
-where
-    S: AsRef<[u8]> + ?Sized,
-{
-    boa_parser::Parser::new(Source::from_bytes(&src))
-        .parse_script(context.interner_mut())
-        .map_err(|e| format!("Uncaught SyntaxError: {e}"))
-}
-
 /// Dumps the AST to stdout with format controlled by the given arguments.
 ///
 /// Returns a error of type String with a error message,
@@ -233,25 +226,41 @@ fn dump<S>(src: &S, args: &Opt, context: &mut Context<'_>) -> Result<(), String>
 where
     S: AsRef<[u8]> + ?Sized,
 {
-    if let Some(ref arg) = args.dump_ast {
+    if let Some(arg) = args.dump_ast {
-        let mut ast = parse_tokens(src, context)?;
+        let arg = arg.unwrap_or_default();
+        let mut parser = boa_parser::Parser::new(Source::from_bytes(src));
+        let dump =
+            if args.module {
+                let module = parser
+                    .parse_module(context.interner_mut())
+                    .map_err(|e| format!("Uncaught SyntaxError: {e}"))?;
+
+                match arg {
+                    DumpFormat::Json => serde_json::to_string(&module)
+                        .expect("could not convert AST to a JSON string"),
+                    DumpFormat::JsonPretty => serde_json::to_string_pretty(&module)
+                        .expect("could not convert AST to a pretty JSON string"),
+                    DumpFormat::Debug => format!("{module:#?}"),
+                }
+            } else {
+                let mut script = parser
+                    .parse_script(context.interner_mut())
+                    .map_err(|e| format!("Uncaught SyntaxError: {e}"))?;
 
                 if args.optimize {
-            context.optimize_statement_list(&mut ast);
+                    context.optimize_statement_list(script.statements_mut());
                 }
 
                 match arg {
-            Some(DumpFormat::Json) => println!(
+                    DumpFormat::Json => serde_json::to_string(&script)
-                "{}",
+                        .expect("could not convert AST to a JSON string"),
-                serde_json::to_string(&ast).expect("could not convert AST to a JSON string")
+                    DumpFormat::JsonPretty => serde_json::to_string_pretty(&script)
-            ),
+                        .expect("could not convert AST to a pretty JSON string"),
-            Some(DumpFormat::JsonPretty) => println!(
+                    DumpFormat::Debug => format!("{script:#?}"),
-                "{}",
-                serde_json::to_string_pretty(&ast)
-                    .expect("could not convert AST to a pretty JSON string")
-            ),
-            Some(DumpFormat::Debug) | None => println!("{ast:#?}"),
                 }
+            };
+
+        println!("{dump}");
     }
 
     Ok(())
@@ -263,8 +272,8 @@ fn generate_flowgraph(
     format: FlowgraphFormat,
     direction: Option<FlowgraphDirection>,
 ) -> JsResult<String> {
-    let ast = context.parse_script(Source::from_bytes(src))?;
+    let script = Script::parse(Source::from_bytes(src), None, context)?;
-    let code = context.compile_script(&ast)?;
+    let code = script.codeblock(context)?;
 
     let direction = match direction {
         Some(FlowgraphDirection::TopToBottom) | None => Direction::TopToBottom,
@@ -327,11 +336,25 @@ fn evaluate_files(
                 Ok(PromiseState::Fulfilled(_)) => {}
                 Ok(PromiseState::Rejected(err)) => {
                     eprintln!("Uncaught {}", err.display());
+
+                    if let Ok(err) = JsError::from_opaque(err).try_native(context) {
+                        if let Some(cause) = err.cause() {
+                            eprintln!("\tCaused by: {cause}");
+                        }
+                    }
+                }
+                Err(err) => {
+                    eprintln!("Uncaught {err}");
+
+                    if let Ok(err) = err.try_native(context) {
+                        if let Some(cause) = err.cause() {
+                            eprintln!("\tCaused by: {cause}");
+                        }
+                    }
                 }
-                Err(err) => eprintln!("Uncaught {err}"),
             }
         } else {
-            match context.eval_script(Source::from_bytes(&buffer)) {
+            match context.eval(Source::from_bytes(&buffer)) {
                 Ok(v) => println!("{}", v.display()),
                 Err(v) => eprintln!("Uncaught {v}"),
             }
@@ -425,7 +448,7 @@ fn main() -> Result<(), io::Error> {
                             Err(v) => eprintln!("Uncaught {v}"),
                         }
                     } else {
-                        match context.eval_script(Source::from_bytes(line.trim_end())) {
+                        match context.eval(Source::from_bytes(line.trim_end())) {
                             Ok(v) => {
                                 println!("{}", v.display());
                             }

boa_engine/benches/full.rs

@@ -2,7 +2,7 @@
 
 use boa_engine::{
     context::DefaultHooks, object::shape::RootShape, optimizer::OptimizerOptions, realm::Realm,
-    Context, Source,
+    script::Script, Context, Source,
 };
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::hint::black_box;
@@ -33,7 +33,13 @@ macro_rules! full_benchmarks {
                     context.set_optimizer_options(OptimizerOptions::empty());
 
                     c.bench_function(concat!($id, " (Parser)"), move |b| {
-                        b.iter(|| context.parse_script(black_box(Source::from_bytes(CODE))))
+                        b.iter(|| {
+                            Script::parse(
+                                black_box(Source::from_bytes(CODE)),
+                                None,
+                                &mut context,
+                            ).unwrap()
+                        })
                     });
                 }
             )*
@@ -42,15 +48,19 @@ macro_rules! full_benchmarks {
             $(
                 {
                     static CODE: &str = include_str!(concat!("bench_scripts/", stringify!($name), ".js"));
-                    let mut context = Context::default();
+                    let context = &mut Context::default();
 
                     // Disable optimizations
                     context.set_optimizer_options(OptimizerOptions::empty());
 
-                    let statement_list = context.parse_script(Source::from_bytes(CODE)).expect("parsing failed");
+                    let script = Script::parse(
+                        black_box(Source::from_bytes(CODE)),
+                        None,
+                        context,
+                    ).unwrap();
                     c.bench_function(concat!($id, " (Compiler)"), move |b| {
                         b.iter(|| {
-                            context.compile_script(black_box(&statement_list))
+                            script.codeblock(context).unwrap()
                         })
                     });
                 }
@@ -60,16 +70,20 @@ macro_rules! full_benchmarks {
             $(
                 {
                     static CODE: &str = include_str!(concat!("bench_scripts/", stringify!($name), ".js"));
-                    let mut context = Context::default();
+                    let context = &mut Context::default();
 
                     // Disable optimizations
                     context.set_optimizer_options(OptimizerOptions::empty());
 
-                    let statement_list = context.parse_script(Source::from_bytes(CODE)).expect("parsing failed");
+                    let script = Script::parse(
-                    let code_block = context.compile_script(&statement_list).unwrap();
+                        black_box(Source::from_bytes(CODE)),
+                        None,
+                        context,
+                    ).unwrap();
+                    script.codeblock(context).unwrap();
                     c.bench_function(concat!($id, " (Execution)"), move |b| {
                         b.iter(|| {
-                            context.execute(black_box(code_block.clone())).unwrap()
+                            script.evaluate(context).unwrap();
                         })
                     });
                 }

boa_engine/src/builtins/eval/mod.rs

@@ -10,8 +10,14 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
 use crate::{
-    builtins::BuiltInObject, bytecompiler::ByteCompiler, context::intrinsics::Intrinsics,
+    builtins::BuiltInObject,
-    environments::Environment, error::JsNativeError, object::JsObject, realm::Realm, vm::Opcode,
+    bytecompiler::ByteCompiler,
+    context::intrinsics::Intrinsics,
+    environments::Environment,
+    error::JsNativeError,
+    object::JsObject,
+    realm::Realm,
+    vm::{CallFrame, Opcode},
     Context, JsArgs, JsResult, JsString, JsValue,
 };
 use boa_ast::operations::{contains, contains_arguments, ContainsSymbol};
@@ -229,7 +235,7 @@ impl Eval {
         let push_env = compiler.emit_opcode_with_two_operands(Opcode::PushDeclarativeEnvironment);
 
         compiler.eval_declaration_instantiation(&body, strict)?;
-        compiler.compile_statement_list(&body, true, false);
+        compiler.compile_statement_list(body.statements(), true, false);
 
         let env_info = compiler.pop_compile_environment();
         compiler.patch_jump_with_target(push_env.0, env_info.num_bindings);
@@ -246,6 +252,11 @@ impl Eval {
             context.vm.environments.extend_outer_function_environment();
         }
 
-        context.execute(code_block)
+        context.vm.push_frame(CallFrame::new(code_block));
+        context.realm().resize_global_env();
+        let record = context.run();
+        context.vm.pop_frame();
+
+        record.consume()
     }
 }

boa_engine/src/builtins/function/mod.rs

@@ -26,16 +26,15 @@ use crate::{
     string::utf16,
     symbol::JsSymbol,
     value::IntegerOrInfinity,
-    vm::CodeBlock,
+    vm::{ActiveRunnable, CodeBlock},
     Context, JsArgs, JsResult, JsString, JsValue,
 };
 use boa_ast::{
-    function::FormalParameterList,
+    function::{FormalParameterList, FunctionBody},
     operations::{
         all_private_identifiers_valid, bound_names, contains, lexically_declared_names,
         ContainsSymbol,
     },
-    StatementList,
 };
 use boa_gc::{self, custom_trace, Finalize, Gc, Trace};
 use boa_interner::Sym;
@@ -177,6 +176,9 @@ pub(crate) enum FunctionKind {
 
         /// The class object that this function is associated with.
         class_object: Option<JsObject>,
+
+        /// The `[[ScriptOrModule]]` internal slot.
+        script_or_module: Option<ActiveRunnable>,
     },
 
     /// A bytecode async function.
@@ -192,6 +194,9 @@ pub(crate) enum FunctionKind {
 
         /// The class object that this function is associated with.
         class_object: Option<JsObject>,
+
+        /// The `[[ScriptOrModule]]` internal slot.
+        script_or_module: Option<ActiveRunnable>,
     },
 
     /// A bytecode generator function.
@@ -207,6 +212,9 @@ pub(crate) enum FunctionKind {
 
         /// The class object that this function is associated with.
         class_object: Option<JsObject>,
+
+        /// The `[[ScriptOrModule]]` internal slot.
+        script_or_module: Option<ActiveRunnable>,
     },
 
     /// A bytecode async generator function.
@@ -222,6 +230,9 @@ pub(crate) enum FunctionKind {
 
         /// The class object that this function is associated with.
         class_object: Option<JsObject>,
+
+        /// The `[[ScriptOrModule]]` internal slot.
+        script_or_module: Option<ActiveRunnable>,
     },
 }
 
@@ -256,7 +267,16 @@ unsafe impl Trace for FunctionKind {
     custom_trace! {this, {
         match this {
             Self::Native { function, .. } => {mark(function)}
-            Self::Ordinary { code, environments, home_object, fields, private_methods, class_object, .. } => {
+            Self::Ordinary {
+                code,
+                environments,
+                home_object,
+                fields,
+                private_methods,
+                class_object,
+                script_or_module,
+                ..
+            } => {
                 mark(code);
                 mark(environments);
                 mark(home_object);
@@ -267,14 +287,16 @@ unsafe impl Trace for FunctionKind {
                     mark(elem);
                 }
                 mark(class_object);
+                mark(script_or_module);
             }
-            Self::Async { code, environments, home_object, class_object }
+            Self::Async { code, environments, home_object, class_object, script_or_module }
-            | Self::Generator { code, environments, home_object, class_object}
+            | Self::Generator { code, environments, home_object, class_object, script_or_module}
-            | Self::AsyncGenerator { code, environments, home_object, class_object} => {
+            | Self::AsyncGenerator { code, environments, home_object, class_object, script_or_module} => {
                 mark(code);
                 mark(environments);
                 mark(home_object);
                 mark(class_object);
+                mark(script_or_module);
             }
         }
     }}
@@ -753,7 +775,7 @@ impl BuiltInFunctionObject {
                 .generator(true)
                 .compile(
                     &FormalParameterList::default(),
-                    &StatementList::default(),
+                    &FunctionBody::default(),
                     context.realm().environment().compile_env(),
                     context,
                 );
@@ -771,7 +793,7 @@ impl BuiltInFunctionObject {
         } else {
             let code = FunctionCompiler::new().name(Sym::ANONYMOUS).compile(
                 &FormalParameterList::default(),
-                &StatementList::default(),
+                &FunctionBody::default(),
                 context.realm().environment().compile_env(),
                 context,
             );

boa_engine/src/builtins/json/mod.rs

@@ -29,6 +29,7 @@ use crate::{
     string::{utf16, CodePoint},
     symbol::JsSymbol,
     value::IntegerOrInfinity,
+    vm::CallFrame,
     Context, JsArgs, JsResult, JsString, JsValue,
 };
 use boa_gc::Gc;
@@ -114,19 +115,25 @@ impl Json {
         // 10. Assert: unfiltered is either a String, Number, Boolean, Null, or an Object that is defined by either an ArrayLiteral or an ObjectLiteral.
         let mut parser = Parser::new(Source::from_bytes(&script_string));
         parser.set_json_parse();
-        let statement_list = parser.parse_script(context.interner_mut())?;
+        let script = parser.parse_script(context.interner_mut())?;
         let code_block = {
             let mut compiler = ByteCompiler::new(
                 Sym::MAIN,
-                statement_list.strict(),
+                script.strict(),
                 true,
                 context.realm().environment().compile_env(),
                 context,
             );
-            compiler.compile_statement_list(&statement_list, true, false);
+            compiler.compile_statement_list(script.statements(), true, false);
             Gc::new(compiler.finish())
         };
-        let unfiltered = context.execute(code_block)?;
+
+        context.vm.push_frame(CallFrame::new(code_block));
+        context.realm().resize_global_env();
+        let record = context.run();
+        context.vm.pop_frame();
+
+        let unfiltered = record.consume()?;
 
         // 11. If IsCallable(reviver) is true, then
         if let Some(obj) = args.get_or_undefined(1).as_callable() {

boa_engine/src/builtins/promise/mod.rs

@@ -2333,7 +2333,7 @@ fn new_promise_reaction_job(
     };
 
     // 4. Return the Record { [[Job]]: job, [[Realm]]: handlerRealm }.
-    NativeJob::with_realm(job, realm)
+    NativeJob::with_realm(job, realm, context)
 }
 
 /// More information:
@@ -2387,5 +2387,5 @@ fn new_promise_resolve_thenable_job(
     };
 
     // 6. Return the Record { [[Job]]: job, [[Realm]]: thenRealm }.
-    NativeJob::with_realm(job, realm)
+    NativeJob::with_realm(job, realm, context)
 }

boa_engine/src/bytecompiler/class.rs

@@ -47,7 +47,7 @@ impl ByteCompiler<'_, '_> {
                 false,
             );
 
-            compiler.compile_statement_list(expr.body(), false, false);
+            compiler.compile_statement_list(expr.body().statements(), false, false);
 
             let env_info = compiler.pop_compile_environment();
 
@@ -370,7 +370,7 @@ impl ByteCompiler<'_, '_> {
                     let index = self.get_or_insert_private_name(*name);
                     self.emit(Opcode::DefinePrivateField, &[index]);
                 }
-                ClassElement::StaticBlock(statement_list) => {
+                ClassElement::StaticBlock(body) => {
                     self.emit_opcode(Opcode::Dup);
                     let mut compiler = ByteCompiler::new(
                         Sym::EMPTY_STRING,
@@ -384,14 +384,14 @@ impl ByteCompiler<'_, '_> {
                     compiler.push_compile_environment(true);
 
                     compiler.function_declaration_instantiation(
-                        statement_list,
+                        body,
                         &FormalParameterList::default(),
                         false,
                         true,
                         false,
                     );
 
-                    compiler.compile_statement_list(statement_list, false, false);
+                    compiler.compile_statement_list(body.statements(), false, false);
                     let env_info = compiler.pop_compile_environment();
                     compiler.pop_compile_environment();
                     compiler.num_bindings = env_info.num_bindings;

boa_engine/src/bytecompiler/declarations.rs

@@ -5,14 +5,14 @@ use crate::{
 };
 use boa_ast::{
     declaration::{Binding, LexicalDeclaration, VariableList},
-    function::FormalParameterList,
+    function::{FormalParameterList, FunctionBody},
     operations::{
-        all_private_identifiers_valid, bound_names, lexically_scoped_declarations,
+        all_private_identifiers_valid, bound_names, lexically_declared_names,
-        top_level_lexically_declared_names, top_level_var_declared_names,
+        lexically_scoped_declarations, var_declared_names, var_scoped_declarations,
-        top_level_var_scoped_declarations, VarScopedDeclaration,
+        LexicallyScopedDeclaration, VarScopedDeclaration,
     },
     visitor::NodeRef,
-    Declaration, StatementList, StatementListItem,
+    Declaration, Script, StatementListItem,
 };
 use boa_interner::Sym;
 
@@ -26,15 +26,12 @@ impl ByteCompiler<'_, '_> {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-globaldeclarationinstantiation
-    pub(crate) fn global_declaration_instantiation(
+    pub(crate) fn global_declaration_instantiation(&mut self, script: &Script) -> JsResult<()> {
-        &mut self,
-        script: &StatementList,
-    ) -> JsResult<()> {
         // 1. Let lexNames be the LexicallyDeclaredNames of script.
-        let lex_names = top_level_lexically_declared_names(script);
+        let lex_names = lexically_declared_names(script);
 
         // 2. Let varNames be the VarDeclaredNames of script.
-        let var_names = top_level_var_declared_names(script);
+        let var_names = var_declared_names(script);
 
         // 3. For each element name of lexNames, do
         for name in lex_names {
@@ -71,7 +68,7 @@ impl ByteCompiler<'_, '_> {
 
         // 5. Let varDeclarations be the VarScopedDeclarations of script.
         // Note: VarScopedDeclarations for a Script node is TopLevelVarScopedDeclarations.
-        let var_declarations = top_level_var_scoped_declarations(script);
+        let var_declarations = var_scoped_declarations(script);
 
         // 6. Let functionsToInitialize be a new empty List.
         let mut functions_to_initialize = Vec::new();
@@ -162,7 +159,7 @@ impl ByteCompiler<'_, '_> {
         // b. If strict is false, then
         #[cfg(feature = "annex-b")]
         if !script.strict() {
-            let lex_names = top_level_lexically_declared_names(script);
+            let lex_names = lexically_declared_names(script);
 
             // i. Let declaredFunctionOrVarNames be the list-concatenation of declaredFunctionNames and declaredVarNames.
             // ii. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause,
@@ -208,7 +205,7 @@ impl ByteCompiler<'_, '_> {
         // 13. Let lexDeclarations be the LexicallyScopedDeclarations of script.
         // 14. Let privateEnv be null.
         // 15. For each element d of lexDeclarations, do
-        for statement in script.statements() {
+        for statement in &**script.statements() {
             // a. NOTE: Lexically declared names are only instantiated here but not initialized.
             // b. For each element dn of the BoundNames of d, do
             //     i. If IsConstantDeclaration of d is true, then
@@ -315,7 +312,8 @@ impl ByteCompiler<'_, '_> {
         // 3. For each element d of declarations, do
         for d in &declarations {
             // i. If IsConstantDeclaration of d is true, then
-            if let Declaration::Lexical(LexicalDeclaration::Const(d)) = d {
+            if let LexicallyScopedDeclaration::LexicalDeclaration(LexicalDeclaration::Const(d)) = d
+            {
                 // a. For each element dn of the BoundNames of d, do
                 for dn in bound_names::<'_, VariableList>(d) {
                     // 1. Perform ! env.CreateImmutableBinding(dn, true).
@@ -325,7 +323,7 @@ impl ByteCompiler<'_, '_> {
             // ii. Else,
             else {
                 // a. For each element dn of the BoundNames of d, do
-                for dn in bound_names::<'_, Declaration>(d) {
+                for dn in d.bound_names() {
                     #[cfg(not(feature = "annex-b"))]
                     // 1. Perform ! env.CreateMutableBinding(dn, false). NOTE: This step is replaced in section B.3.2.6.
                     env.create_mutable_binding(dn, false);
@@ -352,16 +350,16 @@ impl ByteCompiler<'_, '_> {
         // TODO: Support B.3.2.6.
         for d in &declarations {
             match d {
-                Declaration::Function(function) => {
+                LexicallyScopedDeclaration::Function(function) => {
                     self.function(function.into(), NodeKind::Declaration, false);
                 }
-                Declaration::Generator(function) => {
+                LexicallyScopedDeclaration::Generator(function) => {
                     self.function(function.into(), NodeKind::Declaration, false);
                 }
-                Declaration::AsyncFunction(function) => {
+                LexicallyScopedDeclaration::AsyncFunction(function) => {
                     self.function(function.into(), NodeKind::Declaration, false);
                 }
-                Declaration::AsyncGenerator(function) => {
+                LexicallyScopedDeclaration::AsyncGenerator(function) => {
                     self.function(function.into(), NodeKind::Declaration, false);
                 }
                 _ => {}
@@ -379,7 +377,7 @@ impl ByteCompiler<'_, '_> {
     /// [spec]: https://tc39.es/ecma262/#sec-evaldeclarationinstantiation
     pub(crate) fn eval_declaration_instantiation(
         &mut self,
-        body: &StatementList,
+        body: &Script,
         strict: bool,
     ) -> JsResult<()> {
         let var_environment_is_global = self
@@ -390,12 +388,12 @@ impl ByteCompiler<'_, '_> {
             && !strict;
 
         // 2. Let varDeclarations be the VarScopedDeclarations of body.
-        let var_declarations = top_level_var_scoped_declarations(body);
+        let var_declarations = var_scoped_declarations(body);
 
         // 3. If strict is false, then
         if !strict {
             // 1. Let varNames be the VarDeclaredNames of body.
-            let var_names = top_level_var_declared_names(body);
+            let var_names = var_declared_names(body);
 
             // a. If varEnv is a Global Environment Record, then
             //      i. For each element name of varNames, do
@@ -494,7 +492,7 @@ impl ByteCompiler<'_, '_> {
         // 11. If strict is false, then
         #[cfg(feature = "annex-b")]
         if !strict {
-            let lexically_declared_names = top_level_lexically_declared_names(body);
+            let lexically_declared_names = lexically_declared_names(body);
 
             // a. Let declaredFunctionOrVarNames be the list-concatenation of declaredFunctionNames and declaredVarNames.
             // b. For each FunctionDeclaration f that is directly contained in the StatementList
@@ -620,7 +618,7 @@ impl ByteCompiler<'_, '_> {
 
         // 15. Let lexDeclarations be the LexicallyScopedDeclarations of body.
         // 16. For each element d of lexDeclarations, do
-        for statement in body.statements() {
+        for statement in &**body.statements() {
             // a. NOTE: Lexically declared names are only instantiated here but not initialized.
             // b. For each element dn of the BoundNames of d, do
             //     i. If IsConstantDeclaration of d is true, then
@@ -774,7 +772,7 @@ impl ByteCompiler<'_, '_> {
     /// [spec]: https://tc39.es/ecma262/#sec-functiondeclarationinstantiation
     pub(crate) fn function_declaration_instantiation(
         &mut self,
-        code: &StatementList,
+        body: &FunctionBody,
         formals: &FormalParameterList,
         arrow: bool,
         strict: bool,
@@ -801,13 +799,13 @@ impl ByteCompiler<'_, '_> {
         let has_parameter_expressions = formals.has_expressions();
 
         // 9. Let varNames be the VarDeclaredNames of code.
-        let var_names = top_level_var_declared_names(code);
+        let var_names = var_declared_names(body);
 
         // 10. Let varDeclarations be the VarScopedDeclarations of code.
-        let var_declarations = top_level_var_scoped_declarations(code);
+        let var_declarations = var_scoped_declarations(body);
 
         // 11. Let lexicalNames be the LexicallyDeclaredNames of code.
-        let lexical_names = top_level_lexically_declared_names(code);
+        let lexical_names = lexically_declared_names(body);
 
         // 12. Let functionNames be a new empty List.
         let mut function_names = Vec::new();
@@ -1064,7 +1062,7 @@ impl ByteCompiler<'_, '_> {
         if !strict {
             // a. For each FunctionDeclaration f that is directly contained in the StatementList
             //    of a Block, CaseClause, or DefaultClause, do
-            for f in annex_b_function_declarations_names(code) {
+            for f in annex_b_function_declarations_names(body) {
                 // i. Let F be StringValue of the BindingIdentifier of f.
                 // ii. If replacing the FunctionDeclaration f with a VariableStatement that has F
                 //     as a BindingIdentifier would not produce any Early Errors
@@ -1120,7 +1118,7 @@ impl ByteCompiler<'_, '_> {
         //             1. Perform ! lexEnv.CreateImmutableBinding(dn, true).
         //         ii. Else,
         //             1. Perform ! lexEnv.CreateMutableBinding(dn, false).
-        for statement in code.statements() {
+        for statement in &**body.statements() {
             if let StatementListItem::Declaration(declaration) = statement {
                 match declaration {
                     Declaration::Class(class) => {

boa_engine/src/bytecompiler/expression/mod.rs

@@ -320,6 +320,13 @@ impl ByteCompiler<'_, '_> {
                     self.emit_opcode(Opcode::Pop);
                 }
             }
+            Expression::ImportCall(import) => {
+                self.compile_expr(import.argument(), true);
+                self.emit_opcode(Opcode::ImportCall);
+                if !use_expr {
+                    self.emit_opcode(Opcode::Pop);
+                }
+            }
             Expression::NewTarget => {
                 if use_expr {
                     self.emit_opcode(Opcode::PushNewTarget);

boa_engine/src/bytecompiler/function.rs

@@ -5,7 +5,7 @@ use crate::{
     vm::{CodeBlock, Opcode},
     Context,
 };
-use boa_ast::{function::FormalParameterList, StatementList};
+use boa_ast::function::{FormalParameterList, FunctionBody};
 use boa_gc::{Gc, GcRefCell};
 use boa_interner::Sym;
 
@@ -87,7 +87,7 @@ impl FunctionCompiler {
     pub(crate) fn compile(
         mut self,
         parameters: &FormalParameterList,
-        body: &StatementList,
+        body: &FunctionBody,
         outer_env: Gc<GcRefCell<CompileTimeEnvironment>>,
         context: &mut Context<'_>,
     ) -> Gc<CodeBlock> {
@@ -125,7 +125,7 @@ impl FunctionCompiler {
             self.generator,
         );
 
-        compiler.compile_statement_list(body, false, false);
+        compiler.compile_statement_list(body.statements(), false, false);
 
         if let Some(env_labels) = env_labels {
             let env_info = compiler.pop_compile_environment();

boa_engine/src/bytecompiler/mod.rs

@@ -27,7 +27,7 @@ use boa_ast::{
     },
     function::{
         ArrowFunction, AsyncArrowFunction, AsyncFunction, AsyncGenerator, Class,
-        FormalParameterList, Function, Generator, PrivateName,
+        FormalParameterList, Function, FunctionBody, Generator, PrivateName,
     },
     pattern::Pattern,
     Declaration, Expression, Statement, StatementList, StatementListItem,
@@ -64,7 +64,7 @@ pub(crate) struct FunctionSpec<'a> {
     kind: FunctionKind,
     pub(crate) name: Option<Identifier>,
     parameters: &'a FormalParameterList,
-    body: &'a StatementList,
+    body: &'a FunctionBody,
     has_binding_identifier: bool,
 }
 

boa_engine/src/context/hooks.rs

@@ -41,7 +41,7 @@ use super::intrinsics::Intrinsics;
 /// }
 /// let hooks: &dyn HostHooks = &Hooks; // Can have additional state.
 /// let context = &mut ContextBuilder::new().host_hooks(hooks).build().unwrap();
-/// let result = context.eval_script(Source::from_bytes(r#"eval("let a = 5")"#));
+/// let result = context.eval(Source::from_bytes(r#"eval("let a = 5")"#));
 /// assert_eq!(result.unwrap_err().to_string(), "TypeError: eval calls not available");
 /// ```
 ///

boa_engine/src/context/mod.rs

@@ -18,7 +18,6 @@ use std::{io::Read, path::Path, rc::Rc};
 
 use crate::{
     builtins,
-    bytecompiler::ByteCompiler,
     class::{Class, ClassBuilder},
     job::{JobQueue, NativeJob, SimpleJobQueue},
     module::{ModuleLoader, SimpleModuleLoader},
@@ -27,13 +26,12 @@ use crate::{
     optimizer::{Optimizer, OptimizerOptions, OptimizerStatistics},
     property::{Attribute, PropertyDescriptor, PropertyKey},
     realm::Realm,
-    vm::{CallFrame, CodeBlock, Vm},
+    script::Script,
+    vm::{CallFrame, Vm},
     JsResult, JsValue, Source,
 };
 use boa_ast::{expression::Identifier, StatementList};
-use boa_gc::Gc;
+use boa_interner::Interner;
-use boa_interner::{Interner, Sym};
-use boa_parser::Parser;
 use boa_profiler::Profiler;
 
 use crate::vm::RuntimeLimits;
@@ -68,7 +66,7 @@ use crate::vm::RuntimeLimits;
 /// let mut context = Context::default();
 ///
 /// // Populate the script definition to the context.
-/// context.eval_script(Source::from_bytes(script)).unwrap();
+/// context.eval(Source::from_bytes(script)).unwrap();
 ///
 /// // Create an object that can be used in eval calls.
 /// let arg = ObjectInitializer::new(&mut context)
@@ -76,7 +74,7 @@ use crate::vm::RuntimeLimits;
 ///     .build();
 /// context.register_global_property("arg", arg, Attribute::all());
 ///
-/// let value = context.eval_script(Source::from_bytes("test(arg)")).unwrap();
+/// let value = context.eval(Source::from_bytes("test(arg)")).unwrap();
 ///
 /// assert_eq!(value.as_number(), Some(12.0))
 /// ```
@@ -153,7 +151,7 @@ impl<'host> Context<'host> {
         ContextBuilder::default()
     }
 
-    /// Evaluates the given script `src` by compiling down to bytecode, then interpreting the
+    /// Evaluates the given source by compiling down to bytecode, then interpreting the
     /// bytecode into a value.
     ///
     /// # Examples
@@ -162,7 +160,7 @@ impl<'host> Context<'host> {
     /// let mut context = Context::default();
     ///
     /// let source = Source::from_bytes("1 + 3");
-    /// let value = context.eval_script(source).unwrap();
+    /// let value = context.eval(source).unwrap();
     ///
     /// assert!(value.is_number());
     /// assert_eq!(value.as_number().unwrap(), 4.0);
@@ -171,12 +169,10 @@ impl<'host> Context<'host> {
     /// Note that this won't run any scheduled promise jobs; you need to call [`Context::run_jobs`]
     /// on the context or [`JobQueue::run_jobs`] on the provided queue to run them.
     #[allow(clippy::unit_arg, clippy::drop_copy)]
-    pub fn eval_script<R: Read>(&mut self, src: Source<'_, R>) -> JsResult<JsValue> {
+    pub fn eval<R: Read>(&mut self, src: Source<'_, R>) -> JsResult<JsValue> {
         let main_timer = Profiler::global().start_event("Script evaluation", "Main");
 
-        let script = self.parse_script(src)?;
+        let result = Script::parse(src, None, self)?.evaluate(self);
-        let code_block = self.compile_script(&script)?;
-        let result = self.execute(code_block);
 
         // The main_timer needs to be dropped before the Profiler is.
         drop(main_timer);
@@ -194,61 +190,6 @@ impl<'host> Context<'host> {
         optimizer.apply(statement_list)
     }
 
-    /// Parse the given source script.
-    pub fn parse_script<R: Read>(&mut self, src: Source<'_, R>) -> JsResult<StatementList> {
-        let _timer = Profiler::global().start_event("Script parsing", "Main");
-        let mut parser = Parser::new(src);
-        parser.set_identifier(self.next_parser_identifier());
-        if self.strict {
-            parser.set_strict();
-        }
-        let mut result = parser.parse_script(&mut self.interner)?;
-        if !self.optimizer_options().is_empty() {
-            self.optimize_statement_list(&mut result);
-        }
-        Ok(result)
-    }
-
-    /// Compile the script AST into a `CodeBlock` ready to be executed by the VM.
-    pub fn compile_script(&mut self, statement_list: &StatementList) -> JsResult<Gc<CodeBlock>> {
-        let _timer = Profiler::global().start_event("Script compilation", "Main");
-
-        let mut compiler = ByteCompiler::new(
-            Sym::MAIN,
-            statement_list.strict(),
-            false,
-            self.realm.environment().compile_env(),
-            self,
-        );
-        compiler.global_declaration_instantiation(statement_list)?;
-        compiler.compile_statement_list(statement_list, true, false);
-        Ok(Gc::new(compiler.finish()))
-    }
-
-    /// Call the VM with a `CodeBlock` and return the result.
-    ///
-    /// Since this function receives a `Gc<CodeBlock>`, cloning the code is very cheap, since it's
-    /// just a pointer copy. Therefore, if you'd like to execute the same `CodeBlock` multiple
-    /// times, there is no need to re-compile it, and you can just call `clone()` on the
-    /// `Gc<CodeBlock>` returned by the [`Context::compile_script`] function.
-    ///
-    /// Note that this won't run any scheduled promise jobs; you need to call [`Context::run_jobs`]
-    /// on the context or [`JobQueue::run_jobs`] on the provided queue to run them.
-    pub fn execute(&mut self, code_block: Gc<CodeBlock>) -> JsResult<JsValue> {
-        let _timer = Profiler::global().start_event("Execution", "Main");
-
-        self.vm.push_frame(CallFrame::new(code_block));
-
-        // TODO: Here should be https://tc39.es/ecma262/#sec-globaldeclarationinstantiation
-
-        self.realm().resize_global_env();
-        let record = self.run();
-        self.vm.pop_frame();
-        self.clear_kept_objects();
-
-        record.consume()
-    }
-
     /// Register a global property.
     ///
     /// It will return an error if the property is already defined.
@@ -737,6 +678,11 @@ impl Context<'_> {
         // 6. Return true.
         Ok(true)
     }
+
+    /// Returns `true` if this context is in strict mode.
+    pub(crate) const fn is_strict(&self) -> bool {
+        self.strict
+    }
 }
 
 impl<'host> Context<'host> {

boa_engine/src/job.rs

@@ -22,6 +22,7 @@ use std::{any::Any, cell::RefCell, collections::VecDeque, fmt::Debug, future::Fu
 use crate::{
     object::{JsFunction, NativeObject},
     realm::Realm,
+    vm::ActiveRunnable,
     Context, JsResult, JsValue,
 };
 use boa_gc::{Finalize, Trace};
@@ -68,6 +69,7 @@ pub struct NativeJob {
     #[allow(clippy::type_complexity)]
     f: Box<dyn FnOnce(&mut Context<'_>) -> JsResult<JsValue>>,
     realm: Option<Realm>,
+    active_runnable: Option<ActiveRunnable>,
 }
 
 impl Debug for NativeJob {
@@ -85,17 +87,19 @@ impl NativeJob {
         Self {
             f: Box::new(f),
             realm: None,
+            active_runnable: None,
         }
     }
 
     /// Creates a new `NativeJob` from a closure and an execution realm.
-    pub fn with_realm<F>(f: F, realm: Realm) -> Self
+    pub fn with_realm<F>(f: F, realm: Realm, context: &mut Context<'_>) -> Self
     where
         F: FnOnce(&mut Context<'_>) -> JsResult<JsValue> + 'static,
     {
         Self {
             f: Box::new(f),
             realm: Some(realm),
+            active_runnable: context.vm.active_runnable.clone(),
         }
     }
 
@@ -110,11 +114,24 @@ impl NativeJob {
     ///
     /// If the native job has an execution realm defined, this sets the running execution
     /// context to the realm's before calling the inner closure, and resets it after execution.
-    pub fn call(self, context: &mut Context<'_>) -> JsResult<JsValue> {
+    pub fn call(mut self, context: &mut Context<'_>) -> JsResult<JsValue> {
+        // If realm is not null, each time job is invoked the implementation must perform
+        // implementation-defined steps such that execution is prepared to evaluate ECMAScript
+        // code at the time of job's invocation.
         if let Some(realm) = self.realm {
             let old_realm = context.enter_realm(realm);
+
+            // Let scriptOrModule be GetActiveScriptOrModule() at the time HostEnqueuePromiseJob is
+            // invoked. If realm is not null, each time job is invoked the implementation must
+            // perform implementation-defined steps such that scriptOrModule is the active script or
+            // module at the time of job's invocation.
+            std::mem::swap(&mut context.vm.active_runnable, &mut self.active_runnable);
+
             let result = (self.f)(context);
+
             context.enter_realm(old_realm);
+            std::mem::swap(&mut context.vm.active_runnable, &mut self.active_runnable);
+
             result
         } else {
             (self.f)(context)
@@ -173,8 +190,22 @@ impl JobCallback {
 pub trait JobQueue {
     /// [`HostEnqueuePromiseJob ( job, realm )`][spec].
     ///
-    /// Enqueues a [`NativeJob`] on the job queue. Note that host-defined [Jobs] need to satisfy
+    /// Enqueues a [`NativeJob`] on the job queue.
-    /// a set of requirements for them to be spec-compliant.
+    ///
+    /// # Requirements
+    ///
+    /// Per the [spec]:
+    /// > An implementation of `HostEnqueuePromiseJob` must conform to the requirements in [9.5][Jobs] as well as the
+    ///   following:
+    /// > - If `realm` is not null, each time `job` is invoked the implementation must perform implementation-defined steps
+    ///     such that execution is prepared to evaluate ECMAScript code at the time of job's invocation.
+    /// > - Let `scriptOrModule` be `GetActiveScriptOrModule()` at the time `HostEnqueuePromiseJob` is invoked. If realm
+    ///     is not null, each time job is invoked the implementation must perform implementation-defined steps such that
+    ///     `scriptOrModule` is the active script or module at the time of job's invocation.
+    /// > - Jobs must run in the same order as the `HostEnqueuePromiseJob` invocations that scheduled them.
+    ///
+    /// Of all the requirements, Boa guarantees the first two by its internal implementation of `NativeJob`, meaning
+    /// the implementer must only guarantee that jobs are run in the same order as they're enqueued.
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-hostenqueuepromisejob
     /// [Jobs]: https://tc39.es/ecma262/#sec-jobs

boa_engine/src/lib.rs

@@ -22,7 +22,7 @@
 //! let mut context = Context::default();
 //!
 //! // Parse the source code
-//! match context.eval_script(Source::from_bytes(js_code)) {
+//! match context.eval(Source::from_bytes(js_code)) {
 //!     Ok(res) => {
 //!         println!(
 //!             "{}",
@@ -137,6 +137,7 @@ pub mod object;
 pub mod optimizer;
 pub mod property;
 pub mod realm;
+pub mod script;
 pub mod string;
 pub mod symbol;
 // pub(crate) mod tagged;
@@ -153,6 +154,7 @@ pub mod prelude {
         module::Module,
         native_function::NativeFunction,
         object::JsObject,
+        script::Script,
         Context, JsBigInt, JsResult, JsString, JsValue,
     };
     pub use boa_parser::Source;
@@ -169,6 +171,7 @@ pub use crate::{
     module::Module,
     native_function::NativeFunction,
     object::JsObject,
+    script::Script,
     string::JsString,
     symbol::JsSymbol,
     value::JsValue,
@@ -336,7 +339,7 @@ fn run_test_actions(actions: impl IntoIterator<Item = TestAction>) {
 fn run_test_actions_with(actions: impl IntoIterator<Item = TestAction>, context: &mut Context<'_>) {
     #[track_caller]
     fn forward_val(context: &mut Context<'_>, source: &str) -> JsResult<JsValue> {
-        context.eval_script(Source::from_bytes(source))
+        context.eval(Source::from_bytes(source))
     }
 
     #[track_caller]

boa_engine/src/module/mod.rs

@@ -41,6 +41,8 @@ use boa_parser::{Parser, Source};
 use boa_profiler::Profiler;
 
 use crate::object::FunctionObjectBuilder;
+use crate::script::Script;
+use crate::vm::ActiveRunnable;
 use crate::{
     builtins::promise::{PromiseCapability, PromiseState},
     environments::DeclarativeEnvironment,
@@ -51,12 +53,23 @@ use crate::{
 use crate::{js_string, JsNativeError, NativeFunction};
 
 /// The referrer from which a load request of a module originates.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Referrer {
     /// A [**Source Text Module Record**](https://tc39.es/ecma262/#sec-source-text-module-records).
     Module(Module),
     /// A [**Realm**](https://tc39.es/ecma262/#sec-code-realms).
-    Realm(Realm), // TODO: script
+    Realm(Realm),
+    /// A [**Script Record**](https://tc39.es/ecma262/#sec-script-records)
+    Script(Script),
+}
+
+impl From<ActiveRunnable> for Referrer {
+    fn from(value: ActiveRunnable) -> Self {
+        match value {
+            ActiveRunnable::Script(script) => Self::Script(script),
+            ActiveRunnable::Module(module) => Self::Module(module),
+        }
+    }
 }
 
 /// Module loading related host hooks.
@@ -182,7 +195,7 @@ impl ModuleLoader for SimpleModuleLoader {
                     .with_cause(JsError::from_opaque(js_string!(err.to_string()).into()))
             })?;
             let module = Module::parse(source, None, context).map_err(|err| {
-                JsNativeError::error()
+                JsNativeError::syntax()
                     .with_message(format!("could not parse module `{}`", short_path.display()))
                     .with_cause(err)
             })?;

boa_engine/src/module/source.rs

@@ -7,9 +7,8 @@ use boa_ast::{
     },
     operations::{
         bound_names, contains, lexically_scoped_declarations, var_scoped_declarations,
-        ContainsSymbol,
+        ContainsSymbol, LexicallyScopedDeclaration,
     },
-    Declaration, ModuleItemList,
 };
 use boa_gc::{custom_trace, empty_trace, Finalize, Gc, GcRefCell, Trace};
 use boa_interner::Sym;
@@ -22,7 +21,7 @@ use crate::{
     module::ModuleKind,
     object::{FunctionObjectBuilder, JsPromise, RecursionLimiter},
     realm::Realm,
-    vm::{CallFrame, CodeBlock, CompletionRecord, Opcode},
+    vm::{ActiveRunnable, CallFrame, CodeBlock, CompletionRecord, Opcode},
     Context, JsArgs, JsError, JsNativeError, JsObject, JsResult, JsString, JsValue, NativeFunction,
 };
 
@@ -275,7 +274,7 @@ struct Inner {
 struct ModuleCode {
     has_tla: bool,
     requested_modules: FxHashSet<Sym>,
-    node: ModuleItemList,
+    source: boa_ast::Module,
     import_entries: Vec<ImportEntry>,
     local_export_entries: Vec<LocalExportEntry>,
     indirect_export_entries: Vec<IndirectExportEntry>,
@@ -297,16 +296,16 @@ impl SourceTextModule {
             .expect("parent module must be initialized")
     }
 
-    /// Creates a new `SourceTextModule` from a parsed `ModuleItemList`.
+    /// Creates a new `SourceTextModule` from a parsed `ModuleSource`.
     ///
     /// Contains part of the abstract operation [`ParseModule`][parse].
     ///
     /// [parse]: https://tc39.es/ecma262/#sec-parsemodule
-    pub(super) fn new(code: ModuleItemList) -> Self {
+    pub(super) fn new(code: boa_ast::Module) -> Self {
         // 3. Let requestedModules be the ModuleRequests of body.
-        let requested_modules = code.requests();
+        let requested_modules = code.items().requests();
         // 4. Let importEntries be ImportEntries of body.
-        let import_entries = code.import_entries();
+        let import_entries = code.items().import_entries();
 
         // 5. Let importedBoundNames be ImportedLocalNames(importEntries).
         // Can be ignored because this is just a simple `Iter::map`
@@ -319,7 +318,7 @@ impl SourceTextModule {
         let mut star_export_entries = Vec::new();
 
         // 10. For each ExportEntry Record ee of exportEntries, do
-        for ee in code.export_entries() {
+        for ee in code.items().export_entries() {
             match ee {
                 // a. If ee.[[ModuleRequest]] is null, then
                 ExportEntry::Ordinary(entry) => {
@@ -389,7 +388,7 @@ impl SourceTextModule {
                 async_parent_modules: GcRefCell::default(),
                 import_meta: GcRefCell::default(),
                 code: ModuleCode {
-                    node: code,
+                    source: code,
                     requested_modules,
                     has_tla,
                     import_entries,
@@ -615,8 +614,8 @@ impl SourceTextModule {
                     // iii. Else,
                     //    1. Assert: module imports a specific binding for this export.
                     //    2. Return importedModule.ResolveExport(e.[[ImportName]], resolveSet).
-                    ReExportImportName::Name(_) => {
+                    ReExportImportName::Name(name) => {
-                        imported_module.resolve_export(export_name, resolve_set)
+                        imported_module.resolve_export(name, resolve_set)
                     }
                 };
             }
@@ -1470,7 +1469,7 @@ impl SourceTextModule {
 
             // 18. Let code be module.[[ECMAScriptCode]].
             // 19. Let varDeclarations be the VarScopedDeclarations of code.
-            let var_declarations = var_scoped_declarations(&self.inner.code.node);
+            let var_declarations = var_scoped_declarations(&self.inner.code.source);
             // 20. Let declaredVarNames be a new empty List.
             let mut declared_var_names = Vec::new();
             // 21. For each element d of varDeclarations, do
@@ -1494,80 +1493,60 @@ impl SourceTextModule {
 
             // 22. Let lexDeclarations be the LexicallyScopedDeclarations of code.
             // 23. Let privateEnv be null.
-            let lex_declarations = lexically_scoped_declarations(&self.inner.code.node);
+            let lex_declarations = lexically_scoped_declarations(&self.inner.code.source);
             // 24. For each element d of lexDeclarations, do
-            for declaration in lex_declarations {
+            for declaration in &lex_declarations {
-                match &declaration {
                 // i. If IsConstantDeclaration of d is true, then
-                    Declaration::Lexical(LexicalDeclaration::Const(declaration)) => {
+                if let LexicallyScopedDeclaration::LexicalDeclaration(LexicalDeclaration::Const(
+                    decl,
+                )) = declaration
+                {
                     // a. For each element dn of the BoundNames of d, do
-                        for name in bound_names(declaration) {
+                    for name in bound_names(decl) {
                         // 1. Perform ! env.CreateImmutableBinding(dn, true).
                         compiler.create_immutable_binding(name, true);
                     }
-                    }
+                } else {
                     // ii. Else,
-                    Declaration::Lexical(LexicalDeclaration::Let(declaration)) => {
                     // a. For each element dn of the BoundNames of d, do
-                        for name in bound_names(declaration) {
+                    for name in declaration.bound_names() {
                         // 1. Perform ! env.CreateMutableBinding(dn, false).
                         compiler.create_mutable_binding(name, false);
                     }
                 }
+
                 // iii. If d is either a FunctionDeclaration, a GeneratorDeclaration, an
                 //      AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
-                    Declaration::Function(function) => {
-                        // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
-                        // 2. Perform ! env.InitializeBinding(dn, fo).
-                        for name in bound_names(function) {
-                            compiler.create_mutable_binding(name, false);
-                        }
-                        compiler.function(function.into(), NodeKind::Declaration, false);
-                    }
-                    Declaration::Generator(function) => {
-                        // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
-                        // 2. Perform ! env.InitializeBinding(dn, fo).
-                        for name in bound_names(function) {
-                            compiler.create_mutable_binding(name, false);
-                        }
-                        compiler.function(function.into(), NodeKind::Declaration, false);
-                    }
-                    Declaration::AsyncFunction(function) => {
-                        // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
-                        // 2. Perform ! env.InitializeBinding(dn, fo).
-                        for name in bound_names(function) {
-                            compiler.create_mutable_binding(name, false);
-                        }
-                        compiler.function(function.into(), NodeKind::Declaration, false);
-                    }
-                    Declaration::AsyncGenerator(function) => {
                 // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
                 // 2. Perform ! env.InitializeBinding(dn, fo).
-                        for name in bound_names(function) {
+                let spec = match declaration {
-                            compiler.create_mutable_binding(name, false);
+                    LexicallyScopedDeclaration::Function(f) => f.into(),
-                        }
+                    LexicallyScopedDeclaration::Generator(g) => g.into(),
-                        compiler.function(function.into(), NodeKind::Declaration, false);
+                    LexicallyScopedDeclaration::AsyncFunction(af) => af.into(),
-                    }
+                    LexicallyScopedDeclaration::AsyncGenerator(ag) => ag.into(),
-                    Declaration::Class(class) => {
+                    LexicallyScopedDeclaration::Class(_)
-                        // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
+                    | LexicallyScopedDeclaration::LexicalDeclaration(_)
-                        // 2. Perform ! env.InitializeBinding(dn, fo).
+                    | LexicallyScopedDeclaration::AssignmentExpression(_) => continue,
-                        for name in bound_names(class) {
+                };
-                            compiler.create_mutable_binding(name, false);
+
-                        }
+                compiler.function(spec, NodeKind::Declaration, false);
-                    }
-                }
             }
 
-            compiler.compile_module_item_list(&self.inner.code.node);
+            compiler.compile_module_item_list(self.inner.code.source.items());
 
             Gc::new(compiler.finish())
         };
 
         // 8. Let moduleContext be a new ECMAScript code execution context.
-        // 12. Set the ScriptOrModule of moduleContext to module.
         let mut envs = EnvironmentStack::new(global_env);
         envs.push_module(module_compile_env);
 
+        // 12. Set the ScriptOrModule of moduleContext to module.
+        let active_runnable = context
+            .vm
+            .active_runnable
+            .replace(ActiveRunnable::Module(parent.clone()));
+
         // 13. Set the VariableEnvironment of moduleContext to module.[[Environment]].
         // 14. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
         // 15. Set the PrivateEnvironment of moduleContext to null.
@@ -1623,6 +1602,7 @@ impl SourceTextModule {
         std::mem::swap(&mut context.vm.environments, &mut envs);
         context.vm.stack = stack;
         context.vm.active_function = active_function;
+        context.vm.active_runnable = active_runnable;
         context.swap_realm(&mut realm);
 
         debug_assert!(envs.current().as_declarative().is_some());
@@ -1674,6 +1654,11 @@ impl SourceTextModule {
         callframe.promise_capability = capability;
 
         // 4. Set the ScriptOrModule of moduleContext to module.
+        let active_runnable = context
+            .vm
+            .active_runnable
+            .replace(ActiveRunnable::Module(self.parent()));
+
         // 5. Assert: module has been linked and declarations in its module environment have been instantiated.
         // 6. Set the VariableEnvironment of moduleContext to module.[[Environment]].
         // 7. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
@@ -1700,6 +1685,7 @@ impl SourceTextModule {
         std::mem::swap(&mut context.vm.environments, &mut environments);
         context.vm.stack = stack;
         context.vm.active_function = function;
+        context.vm.active_runnable = active_runnable;
         context.swap_realm(&mut realm);
         context.vm.pop_frame();
 
@@ -1712,6 +1698,11 @@ impl SourceTextModule {
             Ok(())
         }
     }
+
+    /// Gets the loaded modules of this module.
+    pub(crate) fn loaded_modules(&self) -> &GcRefCell<FxHashMap<Sym, Module>> {
+        &self.inner.loaded_modules
+    }
 }
 
 /// Abstract operation [`AsyncModuleExecutionFulfilled ( module )`][spec].

boa_engine/src/object/builtins/jspromise.rs

@@ -229,7 +229,7 @@ impl JsPromise {
     /// # fn main() -> Result<(), Box<dyn Error>> {
     /// let context = &mut Context::default();
     ///
-    /// let promise = context.eval_script(Source::from_bytes("new Promise((resolve, reject) => resolve())"))?;
+    /// let promise = context.eval(Source::from_bytes("new Promise((resolve, reject) => resolve())"))?;
     /// let promise = promise.as_object().cloned().unwrap();
     ///
     /// let promise = JsPromise::from_object(promise)?;

boa_engine/src/script.rs

@@ -0,0 +1,163 @@
+//! Boa's implementation of ECMAScript's Scripts.
+//!
+//! This module contains the [`Script`] type, which represents a [**Script Record**][script].
+//!
+//! More information:
+//!  - [ECMAScript reference][spec]
+//!
+//! [spec]: https://tc39.es/ecma262/#sec-scripts
+//! [script]: https://tc39.es/ecma262/#sec-script-records
+
+use std::io::Read;
+
+use boa_gc::{Finalize, Gc, GcRefCell, Trace};
+use boa_interner::Sym;
+use boa_parser::{Parser, Source};
+use boa_profiler::Profiler;
+use rustc_hash::FxHashMap;
+
+use crate::{
+    bytecompiler::ByteCompiler,
+    realm::Realm,
+    vm::{ActiveRunnable, CallFrame, CodeBlock},
+    Context, JsResult, JsString, JsValue, Module,
+};
+
+/// ECMAScript's [**Script Record**][spec].
+///
+/// [spec]: https://tc39.es/ecma262/#sec-script-records
+#[derive(Clone, Trace, Finalize)]
+pub struct Script {
+    inner: Gc<Inner>,
+}
+
+impl std::fmt::Debug for Script {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Script")
+            .field("realm", &self.inner.realm.addr())
+            .field("code", &self.inner.source)
+            .field("loaded_modules", &self.inner.loaded_modules)
+            .field("host_defined", &self.inner.host_defined)
+            .finish()
+    }
+}
+
+#[derive(Trace, Finalize)]
+struct Inner {
+    realm: Realm,
+    #[unsafe_ignore_trace]
+    source: boa_ast::Script,
+    codeblock: GcRefCell<Option<Gc<CodeBlock>>>,
+    loaded_modules: GcRefCell<FxHashMap<JsString, Module>>,
+    host_defined: (),
+}
+
+impl Script {
+    /// Gets the realm of this script.
+    pub fn realm(&self) -> &Realm {
+        &self.inner.realm
+    }
+
+    /// Gets the loaded modules of this script.
+    pub(crate) fn loaded_modules(&self) -> &GcRefCell<FxHashMap<JsString, Module>> {
+        &self.inner.loaded_modules
+    }
+
+    /// Abstract operation [`ParseScript ( sourceText, realm, hostDefined )`][spec].
+    ///
+    /// Parses the provided `src` as an ECMAScript script, returning an error if parsing fails.
+    ///
+    /// [spec]: https://tc39.es/ecma262/#sec-parse-script
+    pub fn parse<R: Read>(
+        src: Source<'_, R>,
+        realm: Option<Realm>,
+        context: &mut Context<'_>,
+    ) -> JsResult<Self> {
+        let _timer = Profiler::global().start_event("Script parsing", "Main");
+        let mut parser = Parser::new(src);
+        parser.set_identifier(context.next_parser_identifier());
+        if context.is_strict() {
+            parser.set_strict();
+        }
+        let mut code = parser.parse_script(context.interner_mut())?;
+        if !context.optimizer_options().is_empty() {
+            context.optimize_statement_list(code.statements_mut());
+        }
+
+        Ok(Self {
+            inner: Gc::new(Inner {
+                realm: realm.unwrap_or_else(|| context.realm().clone()),
+                source: code,
+                codeblock: GcRefCell::default(),
+                loaded_modules: GcRefCell::default(),
+                host_defined: (),
+            }),
+        })
+    }
+
+    /// Compiles the codeblock of this script.
+    ///
+    /// This is a no-op if this has been called previously.
+    pub fn codeblock(&self, context: &mut Context<'_>) -> JsResult<Gc<CodeBlock>> {
+        let mut codeblock = self.inner.codeblock.borrow_mut();
+
+        if let Some(codeblock) = &*codeblock {
+            return Ok(codeblock.clone());
+        };
+
+        let _timer = Profiler::global().start_event("Script compilation", "Main");
+
+        let mut compiler = ByteCompiler::new(
+            Sym::MAIN,
+            self.inner.source.strict(),
+            false,
+            self.inner.realm.environment().compile_env(),
+            context,
+        );
+        // TODO: move to `Script::evaluate` to make this operation infallible.
+        compiler.global_declaration_instantiation(&self.inner.source)?;
+        compiler.compile_statement_list(self.inner.source.statements(), true, false);
+
+        let cb = Gc::new(compiler.finish());
+
+        *codeblock = Some(cb.clone());
+
+        Ok(cb)
+    }
+
+    /// Evaluates this script and returns its result.
+    ///
+    /// Note that this won't run any scheduled promise jobs; you need to call [`Context::run_jobs`]
+    /// on the context or [`JobQueue::run_jobs`] on the provided queue to run them.
+    ///
+    /// [`JobQueue::run_jobs`]: crate::job::JobQueue::run_jobs
+    pub fn evaluate(&self, context: &mut Context<'_>) -> JsResult<JsValue> {
+        let _timer = Profiler::global().start_event("Execution", "Main");
+
+        let codeblock = self.codeblock(context)?;
+
+        let old_realm = context.enter_realm(self.inner.realm.clone());
+        let active_function = context.vm.active_function.take();
+        let stack = std::mem::take(&mut context.vm.stack);
+        let old_active = context
+            .vm
+            .active_runnable
+            .replace(ActiveRunnable::Script(self.clone()));
+        context.vm.push_frame(CallFrame::new(codeblock));
+
+        // TODO: Here should be https://tc39.es/ecma262/#sec-globaldeclarationinstantiation
+
+        self.realm().resize_global_env();
+        let record = context.run();
+        context.vm.pop_frame();
+
+        context.vm.stack = stack;
+        context.vm.active_function = active_function;
+        context.vm.active_runnable = old_active;
+        context.enter_realm(old_realm);
+
+        context.clear_kept_objects();
+
+        record.consume()
+    }
+}

boa_engine/src/vm/code_block.rs

@@ -511,6 +511,7 @@ impl CodeBlock {
             | Opcode::IsObject
             | Opcode::SetNameByLocator
             | Opcode::PopPrivateEnvironment
+            | Opcode::ImportCall
             | Opcode::Nop => String::new(),
         }
     }
@@ -612,6 +613,8 @@ pub(crate) fn create_function_object(
 
     let length: JsValue = code.length.into();
 
+    let script_or_module = context.vm.active_runnable.clone();
+
     let function = if r#async {
         Function::new(
             FunctionKind::Async {
@@ -619,6 +622,7 @@ pub(crate) fn create_function_object(
                 environments: context.vm.environments.clone(),
                 home_object: None,
                 class_object: None,
+                script_or_module,
             },
             context.realm().clone(),
         )
@@ -632,6 +636,7 @@ pub(crate) fn create_function_object(
                 fields: ThinVec::new(),
                 private_methods: ThinVec::new(),
                 class_object: None,
+                script_or_module,
             },
             context.realm().clone(),
         )
@@ -693,12 +698,15 @@ pub(crate) fn create_function_object_fast(
 
     let length: JsValue = code.length.into();
 
+    let script_or_module = context.vm.active_runnable.clone();
+
     let function = if r#async {
         FunctionKind::Async {
             code,
             environments: context.vm.environments.clone(),
             home_object: None,
             class_object: None,
+            script_or_module,
         }
     } else {
         FunctionKind::Ordinary {
@@ -709,6 +717,7 @@ pub(crate) fn create_function_object_fast(
             fields: ThinVec::new(),
             private_methods: ThinVec::new(),
             class_object: None,
+            script_or_module,
         }
     };
 
@@ -799,6 +808,8 @@ pub(crate) fn create_generator_function_object(
         ObjectData::ordinary(),
     );
 
+    let script_or_module = context.vm.active_runnable.clone();
+
     let constructor = if r#async {
         let function = Function::new(
             FunctionKind::AsyncGenerator {
@@ -806,6 +817,7 @@ pub(crate) fn create_generator_function_object(
                 environments: context.vm.environments.clone(),
                 home_object: None,
                 class_object: None,
+                script_or_module,
             },
             context.realm().clone(),
         );
@@ -821,6 +833,7 @@ pub(crate) fn create_generator_function_object(
                 environments: context.vm.environments.clone(),
                 home_object: None,
                 class_object: None,
+                script_or_module,
             },
             context.realm().clone(),
         );
@@ -875,7 +888,8 @@ impl JsObject {
         context.enter_realm(realm);
         context.vm.active_function = Some(active_function);
 
-        let (code, mut environments, class_object, async_, gen) = match function_object.kind() {
+        let (code, mut environments, class_object, mut script_or_module, async_, gen) =
+            match function_object.kind() {
                 FunctionKind::Native {
                     function,
                     constructor,
@@ -895,6 +909,7 @@ impl JsObject {
                     code,
                     environments,
                     class_object,
+                    script_or_module,
                     ..
                 } => {
                     let code = code.clone();
@@ -908,6 +923,7 @@ impl JsObject {
                         code,
                         environments.clone(),
                         class_object.clone(),
+                        script_or_module.clone(),
                         false,
                         false,
                     )
@@ -916,11 +932,14 @@ impl JsObject {
                     code,
                     environments,
                     class_object,
+
+                    script_or_module,
                     ..
                 } => (
                     code.clone(),
                     environments.clone(),
                     class_object.clone(),
+                    script_or_module.clone(),
                     true,
                     false,
                 ),
@@ -928,11 +947,13 @@ impl JsObject {
                     code,
                     environments,
                     class_object,
+                    script_or_module,
                     ..
                 } => (
                     code.clone(),
                     environments.clone(),
                     class_object.clone(),
+                    script_or_module.clone(),
                     false,
                     true,
                 ),
@@ -940,11 +961,14 @@ impl JsObject {
                     code,
                     environments,
                     class_object,
+
+                    script_or_module,
                     ..
                 } => (
                     code.clone(),
                     environments.clone(),
                     class_object.clone(),
+                    script_or_module.clone(),
                     true,
                     true,
                 ),
@@ -1063,6 +1087,8 @@ impl JsObject {
             .with_arg_count(arg_count);
         frame.promise_capability = promise_capability.clone();
 
+        std::mem::swap(&mut context.vm.active_runnable, &mut script_or_module);
+
         context.vm.push_frame(frame);
 
         let result = context
@@ -1073,6 +1099,7 @@ impl JsObject {
         let call_frame = context.vm.pop_frame().expect("frame must exist");
         std::mem::swap(&mut environments, &mut context.vm.environments);
         std::mem::swap(&mut context.vm.stack, &mut stack);
+        std::mem::swap(&mut context.vm.active_runnable, &mut script_or_module);
 
         if let Some(promise_capability) = promise_capability {
             Ok(promise_capability.promise().clone().into())
@@ -1208,10 +1235,12 @@ impl JsObject {
                 code,
                 environments,
                 constructor_kind,
+                script_or_module,
                 ..
             } => {
                 let code = code.clone();
                 let mut environments = environments.clone();
+                let mut script_or_module = script_or_module.clone();
                 let constructor_kind = *constructor_kind;
                 drop(object);
 
@@ -1317,6 +1346,8 @@ impl JsObject {
                 let param_count = code.params.as_ref().len();
                 let has_binding_identifier = code.has_binding_identifier;
 
+                std::mem::swap(&mut context.vm.active_runnable, &mut script_or_module);
+
                 context.vm.push_frame(
                     CallFrame::new(code)
                         .with_param_count(param_count)
@@ -1328,6 +1359,7 @@ impl JsObject {
                 context.vm.pop_frame();
 
                 std::mem::swap(&mut environments, &mut context.vm.environments);
+                std::mem::swap(&mut context.vm.active_runnable, &mut script_or_module);
 
                 let environment = if has_binding_identifier {
                     environments.truncate(environments_len + 2);

boa_engine/src/vm/flowgraph/mod.rs

@@ -593,9 +593,10 @@ impl CodeBlock {
                 | Opcode::SetPrototype
                 | Opcode::IsObject
                 | Opcode::SetNameByLocator
-                | Opcode::Nop
                 | Opcode::PushObjectEnvironment
-                | Opcode::PopPrivateEnvironment => {
+                | Opcode::PopPrivateEnvironment
+                | Opcode::ImportCall
+                | Opcode::Nop => {
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
                 }

boa_engine/src/vm/mod.rs

@@ -9,11 +9,12 @@ use crate::JsNativeError;
 use crate::{
     builtins::async_generator::{AsyncGenerator, AsyncGeneratorState},
     environments::{DeclarativeEnvironment, EnvironmentStack},
+    script::Script,
     vm::code_block::Readable,
-    Context, JsError, JsObject, JsResult, JsValue,
+    Context, JsError, JsObject, JsResult, JsValue, Module,
 };
 
-use boa_gc::Gc;
+use boa_gc::{custom_trace, Finalize, Gc, Trace};
 use boa_profiler::Profiler;
 use std::{convert::TryInto, mem::size_of};
 
@@ -58,6 +59,23 @@ pub struct Vm {
     pub(crate) trace: bool,
     pub(crate) runtime_limits: RuntimeLimits,
     pub(crate) active_function: Option<JsObject>,
+    pub(crate) active_runnable: Option<ActiveRunnable>,
+}
+
+/// Active runnable in the current vm context.
+#[derive(Debug, Clone, Finalize)]
+pub(crate) enum ActiveRunnable {
+    Script(Script),
+    Module(Module),
+}
+
+unsafe impl Trace for ActiveRunnable {
+    custom_trace!(this, {
+        match this {
+            Self::Script(script) => mark(script),
+            Self::Module(module) => mark(module),
+        }
+    });
 }
 
 impl Vm {
@@ -72,6 +90,7 @@ impl Vm {
             trace: false,
             runtime_limits: RuntimeLimits::default(),
             active_function: None,
+            active_runnable: None,
         }
     }
 

boa_engine/src/vm/opcode/call/mod.rs

@@ -1,8 +1,10 @@
 use crate::{
-    builtins::function::FunctionKind,
+    builtins::{function::FunctionKind, promise::PromiseCapability, Promise},
     error::JsNativeError,
+    module::{ModuleKind, Referrer},
+    object::FunctionObjectBuilder,
     vm::{opcode::Operation, CompletionType},
-    Context, JsResult, JsValue,
+    Context, JsResult, JsValue, NativeFunction,
 };
 
 /// `CallEval` implements the Opcode Operation for `Opcode::CallEval`
@@ -250,3 +252,220 @@ impl Operation for CallSpread {
         Ok(CompletionType::Normal)
     }
 }
+
+/// `ImportCall` implements the Opcode Operation for `Opcode::ImportCall`
+///
+/// Operation:
+///  - Dynamically imports a module
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct ImportCall;
+
+impl Operation for ImportCall {
+    const NAME: &'static str = "ImportCall";
+    const INSTRUCTION: &'static str = "INST - ImportCall";
+
+    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
+        // Import Calls
+        // Runtime Semantics: Evaluation
+        // https://tc39.es/ecma262/#sec-import-call-runtime-semantics-evaluation
+
+        // 1. Let referrer be GetActiveScriptOrModule().
+        // 2. If referrer is null, set referrer to the current Realm Record.
+        let referrer = context
+            .vm
+            .active_runnable
+            .clone()
+            .map_or_else(|| Referrer::Realm(context.realm().clone()), Into::into);
+
+        // 3. Let argRef be ? Evaluation of AssignmentExpression.
+        // 4. Let specifier be ? GetValue(argRef).
+        let arg = context.vm.pop();
+
+        // 5. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+        let cap = PromiseCapability::new(
+            &context.intrinsics().constructors().promise().constructor(),
+            context,
+        )
+        .expect("operation cannot fail for the %Promise% intrinsic");
+        let promise = cap.promise().clone();
+
+        // 6. Let specifierString be Completion(ToString(specifier)).
+        match arg.to_string(context) {
+            // 7. IfAbruptRejectPromise(specifierString, promiseCapability).
+            Err(err) => {
+                let err = err.to_opaque(context);
+                cap.reject().call(&JsValue::undefined(), &[err], context)?;
+            }
+            // 8. Perform HostLoadImportedModule(referrer, specifierString, empty, promiseCapability).
+            Ok(specifier) => context.module_loader().load_imported_module(
+                referrer.clone(),
+                specifier.clone(),
+                Box::new(move |completion, context| {
+                    // `ContinueDynamicImport ( promiseCapability, moduleCompletion )`
+                    // https://tc39.es/ecma262/#sec-ContinueDynamicImport
+
+                    // `FinishLoadingImportedModule ( referrer, specifier, payload, result )`
+                    // https://tc39.es/ecma262/#sec-FinishLoadingImportedModule
+                    let module = match completion {
+                        // 1. If result is a normal completion, then
+                        Ok(m) => {
+                            match referrer {
+                                Referrer::Module(module) => {
+                                    let ModuleKind::SourceText(src) = module.kind() else {
+                                        panic!("referrer cannot be a synthetic module");
+                                    };
+
+                                    let sym = context.interner_mut().get_or_intern(&*specifier);
+
+                                    let mut loaded_modules = src.loaded_modules().borrow_mut();
+
+                                    //     a. If referrer.[[LoadedModules]] contains a Record whose [[Specifier]] is specifier, then
+                                    //     b. Else,
+                                    //         i. Append the Record { [[Specifier]]: specifier, [[Module]]: result.[[Value]] } to referrer.[[LoadedModules]].
+                                    let entry =
+                                        loaded_modules.entry(sym).or_insert_with(|| m.clone());
+
+                                    //         i. Assert: That Record's [[Module]] is result.[[Value]].
+                                    debug_assert_eq!(&m, entry);
+
+                                    // Same steps apply to referrers below
+                                }
+                                Referrer::Realm(realm) => {
+                                    let mut loaded_modules = realm.loaded_modules().borrow_mut();
+                                    let entry = loaded_modules
+                                        .entry(specifier)
+                                        .or_insert_with(|| m.clone());
+                                    debug_assert_eq!(&m, entry);
+                                }
+                                Referrer::Script(script) => {
+                                    let mut loaded_modules = script.loaded_modules().borrow_mut();
+                                    let entry = loaded_modules
+                                        .entry(specifier)
+                                        .or_insert_with(|| m.clone());
+                                    debug_assert_eq!(&m, entry);
+                                }
+                            }
+
+                            m
+                        }
+                        // 1. If moduleCompletion is an abrupt completion, then
+                        Err(err) => {
+                            // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « moduleCompletion.[[Value]] »).
+                            let err = err.to_opaque(context);
+                            cap.reject()
+                                .call(&JsValue::undefined(), &[err], context)
+                                .expect("default `reject` function cannot throw");
+
+                            // b. Return unused.
+                            return;
+                        }
+                    };
+
+                    // 2. Let module be moduleCompletion.[[Value]].
+                    // 3. Let loadPromise be module.LoadRequestedModules().
+                    let load = module.load(context);
+
+                    // 4. Let rejectedClosure be a new Abstract Closure with parameters (reason) that captures promiseCapability and performs the following steps when called:
+                    // 5. Let onRejected be CreateBuiltinFunction(rejectedClosure, 1, "", « »).
+                    let on_rejected = FunctionObjectBuilder::new(
+                        context,
+                        NativeFunction::from_copy_closure_with_captures(
+                            |_, args, cap, context| {
+                                //     a. Perform ! Call(promiseCapability.[[Reject]], undefined, « reason »).
+                                cap.reject()
+                                    .call(&JsValue::undefined(), args, context)
+                                    .expect("default `reject` function cannot throw");
+
+                                //     b. Return unused.
+                                Ok(JsValue::undefined())
+                            },
+                            cap.clone(),
+                        ),
+                    )
+                    .build();
+
+                    // 6. Let linkAndEvaluateClosure be a new Abstract Closure with no parameters that captures module, promiseCapability, and onRejected and performs the following steps when called:
+                    // 7. Let linkAndEvaluate be CreateBuiltinFunction(linkAndEvaluateClosure, 0, "", « »).
+                    let link_evaluate = FunctionObjectBuilder::new(
+                        context,
+                        NativeFunction::from_copy_closure_with_captures(
+                            |_, _, (module, cap, on_rejected), context| {
+                                // a. Let link be Completion(module.Link()).
+                                // b. If link is an abrupt completion, then
+                                if let Err(e) = module.link(context) {
+                                    // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « link.[[Value]] »).
+                                    let e = e.to_opaque(context);
+                                    cap.reject()
+                                        .call(&JsValue::undefined(), &[e], context)
+                                        .expect("default `reject` function cannot throw");
+                                    // ii. Return unused.
+                                    return Ok(JsValue::undefined());
+                                }
+
+                                // c. Let evaluatePromise be module.Evaluate().
+                                let evaluate = module.evaluate(context);
+
+                                // d. Let fulfilledClosure be a new Abstract Closure with no parameters that captures module and promiseCapability and performs the following steps when called:
+                                // e. Let onFulfilled be CreateBuiltinFunction(fulfilledClosure, 0, "", « »).
+                                let fulfill = FunctionObjectBuilder::new(
+                                    context,
+                                    NativeFunction::from_copy_closure_with_captures(
+                                        |_, _, (module, cap), context| {
+                                            // i. Let namespace be GetModuleNamespace(module).
+                                            let namespace = module.namespace(context);
+
+                                            // ii. Perform ! Call(promiseCapability.[[Resolve]], undefined, « namespace »).
+                                            cap.resolve()
+                                                .call(
+                                                    &JsValue::undefined(),
+                                                    &[namespace.into()],
+                                                    context,
+                                                )
+                                                .expect("default `resolve` function cannot throw");
+
+                                            // iii. Return unused.
+                                            Ok(JsValue::undefined())
+                                        },
+                                        (module.clone(), cap.clone()),
+                                    ),
+                                )
+                                .build();
+
+                                // f. Perform PerformPromiseThen(evaluatePromise, onFulfilled, onRejected).
+                                Promise::perform_promise_then(
+                                    &evaluate,
+                                    Some(fulfill),
+                                    Some(on_rejected.clone()),
+                                    None,
+                                    context,
+                                );
+
+                                // g. Return unused.
+                                Ok(JsValue::undefined())
+                            },
+                            (module.clone(), cap.clone(), on_rejected.clone()),
+                        ),
+                    )
+                    .build();
+
+                    // 8. Perform PerformPromiseThen(loadPromise, linkAndEvaluate, onRejected).
+                    Promise::perform_promise_then(
+                        &load,
+                        Some(link_evaluate),
+                        Some(on_rejected),
+                        None,
+                        context,
+                    );
+
+                    // 9. Return unused.
+                }),
+                context,
+            ),
+        };
+
+        // 9. Return promiseCapability.[[Promise]].
+        context.vm.push(promise);
+
+        Ok(CompletionType::Normal)
+    }
+}

boa_engine/src/vm/opcode/mod.rs

@@ -1230,6 +1230,13 @@ generate_impl! {
         /// Stack: argument_1, ... argument_n **=>**
         SuperCallDerived,
 
+        /// Dynamically import a module.
+        ///
+        /// Operands:
+        ///
+        /// Stack: specifier **=>** promise
+        ImportCall,
+
         /// Pop the two values of the stack, strict equal compares the two values,
         /// if true jumps to address, otherwise push the second pop'ed value.
         ///

boa_examples/src/bin/classes.rs

@@ -149,7 +149,7 @@ fn main() {
     // Having done all of that, we can execute Javascript code with `eval`,
     // and access the `Person` class defined in Rust!
     context
-        .eval_script(Source::from_bytes(
+        .eval(Source::from_bytes(
             r"
 		let person = new Person('John', 19);
 		person.sayHello();

boa_examples/src/bin/closures.rs

@@ -38,10 +38,7 @@ fn main() -> Result<(), JsError> {
         )
         .unwrap();
 
-    assert_eq!(
+    assert_eq!(context.eval(Source::from_bytes("closure()"))?, 255.into());
-        context.eval_script(Source::from_bytes("closure()"))?,
-        255.into()
-    );
 
     // We have created a closure with moved variables and executed that closure
     // inside Javascript!
@@ -124,13 +121,13 @@ fn main() -> Result<(), JsError> {
         .unwrap();
 
     assert_eq!(
-        context.eval_script(Source::from_bytes("createMessage()"))?,
+        context.eval(Source::from_bytes("createMessage()"))?,
         "message from `Boa dev`: Hello!".into()
     );
 
     // The data mutates between calls
     assert_eq!(
-        context.eval_script(Source::from_bytes("createMessage(); createMessage();"))?,
+        context.eval(Source::from_bytes("createMessage(); createMessage();"))?,
         "message from `Boa dev`: Hello! Hello! Hello!".into()
     );
 
@@ -174,7 +171,7 @@ fn main() -> Result<(), JsError> {
         .unwrap();
 
     // First call should return the array `[0]`.
-    let result = context.eval_script(Source::from_bytes("enumerate()"))?;
+    let result = context.eval(Source::from_bytes("enumerate()"))?;
     let object = result
         .as_object()
         .cloned()
@@ -185,7 +182,7 @@ fn main() -> Result<(), JsError> {
     assert_eq!(array.get(1, &mut context)?, JsValue::undefined());
 
     // First call should return the array `[0, 1]`.
-    let result = context.eval_script(Source::from_bytes("enumerate()"))?;
+    let result = context.eval(Source::from_bytes("enumerate()"))?;
     let object = result
         .as_object()
         .cloned()

boa_examples/src/bin/commuter_visitor.rs

@@ -69,14 +69,14 @@ fn main() {
         Parser::new(Source::from_filepath(Path::new("boa_examples/scripts/calc.js")).unwrap());
     let mut ctx = Context::default();
 
-    let mut statements = parser.parse_script(ctx.interner_mut()).unwrap();
+    let mut script = parser.parse_script(ctx.interner_mut()).unwrap();
 
     let mut visitor = CommutorVisitor::default();
 
     assert!(matches!(
-        visitor.visit_statement_list_mut(&mut statements),
+        visitor.visit_statement_list_mut(script.statements_mut()),
         ControlFlow::Continue(_)
     ));
 
-    println!("{}", statements.to_interned_string(ctx.interner()));
+    println!("{}", script.to_interned_string(ctx.interner()));
 }

boa_examples/src/bin/derive.rs

@@ -26,7 +26,7 @@ fn main() {
     let js = Source::from_bytes(js_str);
 
     let mut context = Context::default();
-    let res = context.eval_script(js).unwrap();
+    let res = context.eval(js).unwrap();
 
     let str = TestStruct::try_from_js(&res, &mut context)
         .map_err(|e| e.to_string())

boa_examples/src/bin/futures.rs

@@ -166,7 +166,7 @@ fn main() {
     "#;
 
     let now = Instant::now();
-    context.eval_script(Source::from_bytes(script)).unwrap();
+    context.eval(Source::from_bytes(script)).unwrap();
 
     // Important to run this after evaluating, since this is what triggers to run the enqueued jobs.
     context.run_jobs();

boa_examples/src/bin/loadfile.rs

@@ -13,7 +13,7 @@ fn main() {
             // Instantiate the execution context
             let mut context = Context::default();
             // Parse the source code
-            match context.eval_script(src) {
+            match context.eval(src) {
                 Ok(res) => {
                     println!(
                         "{}",

boa_examples/src/bin/loadstring.rs

@@ -9,7 +9,7 @@ fn main() {
     let mut context = Context::default();
 
     // Parse the source code
-    match context.eval_script(Source::from_bytes(js_code)) {
+    match context.eval(Source::from_bytes(js_code)) {
         Ok(res) => {
             println!(
                 "{}",

boa_examples/src/bin/modulehandler.rs

@@ -33,8 +33,7 @@ fn main() {
 
     // Instantiating the engine with the execution context
     // Loading, parsing and executing the JS code from the source file
-    ctx.eval_script(Source::from_bytes(&buffer.unwrap()))
+    ctx.eval(Source::from_bytes(&buffer.unwrap())).unwrap();
-        .unwrap();
 }
 
 // Custom implementation that mimics the 'require' module loader
@@ -55,8 +54,7 @@ fn require(_: &JsValue, args: &[JsValue], ctx: &mut Context<'_>) -> JsResult<JsV
         Ok(JsValue::Rational(-1.0))
     } else {
         // Load and parse the module source
-        ctx.eval_script(Source::from_bytes(&buffer.unwrap()))
+        ctx.eval(Source::from_bytes(&buffer.unwrap())).unwrap();
-            .unwrap();
 
         // Access module.exports and return as ResultValue
         let global_obj = ctx.global_object();

boa_examples/src/bin/runtime_limits.rs

@@ -12,7 +12,7 @@ fn main() {
     context.runtime_limits_mut().set_loop_iteration_limit(10);
 
     // The code below iterates 5 times, so no error is thrown.
-    let result = context.eval_script(Source::from_bytes(
+    let result = context.eval(Source::from_bytes(
         r"
             for (let i = 0; i < 5; ++i) { }
         ",
@@ -22,7 +22,7 @@ fn main() {
     // Here we exceed the limit by 1 iteration and a `RuntimeLimit` error is thrown.
     //
     // This error cannot be caught in JavaScript it propagates to rust caller.
-    let result = context.eval_script(Source::from_bytes(
+    let result = context.eval(Source::from_bytes(
         r"
             try {
                 for (let i = 0; i < 11; ++i) { }
@@ -34,7 +34,7 @@ fn main() {
     assert!(result.is_err());
 
     // Preventing an infinity loops
-    let result = context.eval_script(Source::from_bytes(
+    let result = context.eval(Source::from_bytes(
         r"
             while (true) { }
         ",
@@ -42,7 +42,7 @@ fn main() {
     assert!(result.is_err());
 
     // The limit applies to all types of loops.
-    let result = context.eval_script(Source::from_bytes(
+    let result = context.eval(Source::from_bytes(
         r"
             for (let e of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) { }
         ",
@@ -54,7 +54,7 @@ fn main() {
     // -----------------------------------------
 
     // Create and register `factorial` function.
-    let result = context.eval_script(Source::from_bytes(
+    let result = context.eval(Source::from_bytes(
         r"
             function factorial(n) {
                 if (n == 0) {
@@ -68,17 +68,17 @@ fn main() {
     assert!(result.is_ok());
 
     // Run function before setting the limit and assert that it works.
-    let result = context.eval_script(Source::from_bytes("factorial(11)"));
+    let result = context.eval(Source::from_bytes("factorial(11)"));
     assert_eq!(result, Ok(JsValue::new(39_916_800)));
 
     // Setting runtime limit for recustion to 10.
     context.runtime_limits_mut().set_recursion_limit(10);
 
     // Run without exceeding recursion limit and assert that it works.
-    let result = context.eval_script(Source::from_bytes("factorial(8)"));
+    let result = context.eval(Source::from_bytes("factorial(8)"));
     assert_eq!(result, Ok(JsValue::new(40_320)));
 
     // Run exceeding limit by 1 and assert that it fails.
-    let result = context.eval_script(Source::from_bytes("factorial(11)"));
+    let result = context.eval(Source::from_bytes("factorial(11)"));
     assert!(result.is_err());
 }

boa_examples/src/bin/symbol_visitor.rs

@@ -28,12 +28,12 @@ fn main() {
         Parser::new(Source::from_filepath(Path::new("boa_examples/scripts/calc.js")).unwrap());
     let mut ctx = Context::default();
 
-    let statements = parser.parse_script(ctx.interner_mut()).unwrap();
+    let script = parser.parse_script(ctx.interner_mut()).unwrap();
 
     let mut visitor = SymbolVisitor::default();
 
     assert!(matches!(
-        visitor.visit_statement_list(&statements),
+        visitor.visit_statement_list(script.statements()),
         ControlFlow::Continue(_)
     ));
 

boa_parser/src/parser/expression/assignment/arrow_function.rs

@@ -18,7 +18,7 @@ use crate::{
         TokenParser,
     },
 };
-use ast::operations::{bound_names, top_level_lexically_declared_names};
+use ast::operations::{bound_names, lexically_declared_names};
 use boa_ast::{
     self as ast,
     declaration::Variable,
@@ -159,7 +159,7 @@ where
         // https://tc39.es/ecma262/#sec-arrow-function-definitions-static-semantics-early-errors
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;
@@ -190,25 +190,28 @@ impl<R> TokenParser<R> for ConciseBody
 where
     R: Read,
 {
-    type Output = StatementList;
+    type Output = ast::function::FunctionBody;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
+        let stmts =
             match cursor.peek(0, interner).or_abrupt()?.kind() {
                 TokenKind::Punctuator(Punctuator::OpenBlock) => {
                     cursor.advance(interner);
                     let body = FunctionBody::new(false, false).parse(cursor, interner)?;
                     cursor.expect(Punctuator::CloseBlock, "arrow function", interner)?;
-                Ok(body)
+                    body
                 }
-            _ => Ok(StatementList::from(vec![ast::Statement::Return(
+                _ => ast::function::FunctionBody::new(StatementList::from(vec![
-                Return::new(
+                    ast::Statement::Return(Return::new(
                         ExpressionBody::new(self.allow_in, false)
                             .parse(cursor, interner)?
                             .into(),
-                ),
+                    ))
-            )
+                    .into(),
-            .into()])),
+                ])),
-        }
+            };
+
+        Ok(stmts)
     }
 }
 

boa_parser/src/parser/expression/assignment/async_arrow_function.rs

@@ -18,7 +18,7 @@ use crate::{
     },
 };
 use ast::{
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
     Keyword,
 };
 use boa_ast::{
@@ -145,7 +145,7 @@ where
         // also occurs in the LexicallyDeclaredNames of AsyncConciseBody.
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;
@@ -178,24 +178,27 @@ impl<R> TokenParser<R> for AsyncConciseBody
 where
     R: Read,
 {
-    type Output = StatementList;
+    type Output = ast::function::FunctionBody;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
+        let body =
             match cursor.peek(0, interner).or_abrupt()?.kind() {
                 TokenKind::Punctuator(Punctuator::OpenBlock) => {
                     cursor.advance(interner);
                     let body = FunctionBody::new(false, true).parse(cursor, interner)?;
                     cursor.expect(Punctuator::CloseBlock, "async arrow function", interner)?;
-                Ok(body)
+                    body
                 }
-            _ => Ok(StatementList::from(vec![ast::Statement::Return(
+                _ => ast::function::FunctionBody::new(StatementList::from(vec![
-                Return::new(
+                    ast::Statement::Return(Return::new(
                         ExpressionBody::new(self.allow_in, true)
                             .parse(cursor, interner)?
                             .into(),
-                ),
+                    ))
-            )
+                    .into(),
-            .into()])),
+                ])),
-        }
+            };
+
+        Ok(body)
     }
 }

boa_parser/src/parser/expression/assignment/mod.rs

@@ -32,7 +32,7 @@ use boa_ast::{
         operator::assign::{Assign, AssignOp, AssignTarget},
         Identifier,
     },
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
     Expression, Keyword, Punctuator,
 };
 use boa_interner::Interner;
@@ -225,7 +225,7 @@ where
             // https://tc39.es/ecma262/#sec-arrow-function-definitions-static-semantics-early-errors
             name_in_lexically_declared_names(
                 &bound_names(&parameters),
-                &top_level_lexically_declared_names(&body),
+                &lexically_declared_names(&body),
                 position,
                 interner,
             )?;

boa_parser/src/parser/expression/left_hand_side/call.rs

@@ -72,7 +72,7 @@ where
 
         let token = cursor.peek(0, interner).or_abrupt()?;
 
-        let mut lhs = if token.kind() == &TokenKind::Punctuator(Punctuator::OpenParen) {
+        let lhs = if token.kind() == &TokenKind::Punctuator(Punctuator::OpenParen) {
             let args =
                 Arguments::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
             Call::new(self.first_member_expr, args).into()
@@ -86,6 +86,42 @@ where
             ));
         };
 
+        CallExpressionTail::new(self.allow_yield, self.allow_await, lhs).parse(cursor, interner)
+    }
+}
+
+/// Parses the tail parts of a call expression (property access, sucessive call, array access).
+#[derive(Debug)]
+pub(super) struct CallExpressionTail {
+    allow_yield: AllowYield,
+    allow_await: AllowAwait,
+    call: ast::Expression,
+}
+
+impl CallExpressionTail {
+    /// Creates a new `CallExpressionTail` parser.
+    pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A, call: ast::Expression) -> Self
+    where
+        Y: Into<AllowYield>,
+        A: Into<AllowAwait>,
+    {
+        Self {
+            allow_yield: allow_yield.into(),
+            allow_await: allow_await.into(),
+            call,
+        }
+    }
+}
+
+impl<R> TokenParser<R> for CallExpressionTail
+where
+    R: Read,
+{
+    type Output = ast::Expression;
+
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
+        let mut lhs = self.call;
+
         while let Some(tok) = cursor.peek(0, interner)? {
             let token = tok.clone();
             match token.kind() {
@@ -147,6 +183,7 @@ where
                 _ => break,
             }
         }
+
         Ok(lhs)
     }
 }

boa_parser/src/parser/expression/left_hand_side/mod.rs

@@ -19,15 +19,21 @@ mod template;
 use crate::{
     lexer::{InputElement, TokenKind},
     parser::{
-        expression::left_hand_side::{
+        expression::{
-            arguments::Arguments, call::CallExpression, member::MemberExpression,
+            left_hand_side::{
+                arguments::Arguments,
+                call::{CallExpression, CallExpressionTail},
+                member::MemberExpression,
                 optional::OptionalExpression,
             },
-        AllowAwait, AllowYield, Cursor, ParseResult, TokenParser,
+            AssignmentExpression,
         },
+        AllowAwait, AllowYield, Cursor, OrAbrupt, ParseResult, TokenParser,
+    },
+    Error,
 };
 use boa_ast::{
-    expression::{Identifier, SuperCall},
+    expression::{Identifier, ImportCall, SuperCall},
     Expression, Keyword, Punctuator,
 };
 use boa_interner::Interner;
@@ -96,6 +102,7 @@ where
             }
             Ok(false)
         }
+
         let _timer = Profiler::global().start_event("LeftHandSideExpression", "Parsing");
 
         cursor.set_goal(InputElement::TemplateTail);
@@ -106,7 +113,39 @@ where
                 Arguments::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
             SuperCall::new(args).into()
         } else {
-            let mut member = MemberExpression::new(self.name, self.allow_yield, self.allow_await)
+            let next = cursor.peek(0, interner).or_abrupt()?;
+            if let TokenKind::Keyword((Keyword::Import, escaped)) = next.kind() {
+                if *escaped {
+                    return Err(Error::general(
+                        "keyword `import` must not contain escaped characters",
+                        next.span().start(),
+                    ));
+                }
+                cursor.advance(interner);
+                cursor.expect(
+                    TokenKind::Punctuator(Punctuator::OpenParen),
+                    "import call",
+                    interner,
+                )?;
+
+                let arg = AssignmentExpression::new(None, true, self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
+
+                cursor.expect(
+                    TokenKind::Punctuator(Punctuator::CloseParen),
+                    "import call",
+                    interner,
+                )?;
+
+                CallExpressionTail::new(
+                    self.allow_yield,
+                    self.allow_await,
+                    ImportCall::new(arg).into(),
+                )
+                .parse(cursor, interner)?
+            } else {
+                let mut member =
+                    MemberExpression::new(self.name, self.allow_yield, self.allow_await)
                         .parse(cursor, interner)?;
                 if let Some(tok) = cursor.peek(0, interner)? {
                     if tok.kind() == &TokenKind::Punctuator(Punctuator::OpenParen) {
@@ -115,6 +154,7 @@ where
                     }
                 }
                 member
+            }
         };
 
         if let Some(tok) = cursor.peek(0, interner)? {

boa_parser/src/parser/expression/primary/async_function_expression/mod.rs

@@ -13,7 +13,7 @@ use crate::{
 use boa_ast::{
     expression::Identifier,
     function::AsyncFunction,
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
     Keyword, Punctuator,
 };
 use boa_interner::{Interner, Sym};
@@ -140,7 +140,7 @@ where
         // https://tc39.es/ecma262/#sec-function-definitions-static-semantics-early-errors
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;

boa_parser/src/parser/expression/primary/async_function_expression/tests.rs

@@ -2,7 +2,7 @@ use crate::parser::tests::check_script_parser;
 use boa_ast::{
     declaration::{Declaration, LexicalDeclaration, Variable},
     expression::literal::Literal,
-    function::{AsyncFunction, FormalParameterList},
+    function::{AsyncFunction, FormalParameterList, FunctionBody},
     statement::Return,
     Statement, StatementListItem,
 };
@@ -26,10 +26,12 @@ fn check_async_expression() {
                     AsyncFunction::new(
                         Some(add.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(Literal::from(1).into())),
                             ))]
                             .into(),
+                        ),
                         false,
                     )
                     .into(),
@@ -62,6 +64,7 @@ fn check_nested_async_expression() {
                     AsyncFunction::new(
                         Some(a.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![Declaration::Lexical(LexicalDeclaration::Const(
                                 vec![Variable::from_identifier(
                                     b.into(),
@@ -69,11 +72,13 @@ fn check_nested_async_expression() {
                                         AsyncFunction::new(
                                             Some(b.into()),
                                             FormalParameterList::default(),
+                                            FunctionBody::new(
                                                 vec![Statement::Return(Return::new(Some(
                                                     Literal::from(1).into(),
                                                 )))
                                                 .into()]
                                                 .into(),
+                                            ),
                                             false,
                                         )
                                         .into(),
@@ -84,6 +89,7 @@ fn check_nested_async_expression() {
                             ))
                             .into()]
                             .into(),
+                        ),
                         false,
                     )
                     .into(),

boa_parser/src/parser/expression/primary/async_generator_expression/mod.rs

@@ -22,7 +22,7 @@ use crate::{
 use boa_ast::{
     expression::Identifier,
     function::AsyncGenerator,
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
     Keyword, Punctuator,
 };
 use boa_interner::{Interner, Sym};
@@ -177,7 +177,7 @@ where
         // also occurs in the LexicallyDeclaredNames of FunctionBody.
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;

boa_parser/src/parser/expression/primary/async_generator_expression/tests.rs

@@ -2,7 +2,7 @@ use crate::parser::tests::check_script_parser;
 use boa_ast::{
     declaration::{LexicalDeclaration, Variable},
     expression::literal::Literal,
-    function::{AsyncGenerator, FormalParameterList},
+    function::{AsyncGenerator, FormalParameterList, FunctionBody},
     statement::Return,
     Declaration, Statement, StatementListItem,
 };
@@ -27,10 +27,12 @@ fn check_async_generator_expr() {
                     AsyncGenerator::new(
                         Some(add.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(Literal::from(1).into())),
                             ))]
                             .into(),
+                        ),
                         false,
                     )
                     .into(),
@@ -63,6 +65,7 @@ fn check_nested_async_generator_expr() {
                     AsyncGenerator::new(
                         Some(a.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![Declaration::Lexical(LexicalDeclaration::Const(
                                 vec![Variable::from_identifier(
                                     b.into(),
@@ -70,10 +73,14 @@ fn check_nested_async_generator_expr() {
                                         AsyncGenerator::new(
                                             Some(b.into()),
                                             FormalParameterList::default(),
-                                        vec![StatementListItem::Statement(Statement::Return(
+                                            FunctionBody::new(
-                                            Return::new(Some(Literal::from(1).into())),
+                                                vec![StatementListItem::Statement(
-                                        ))]
+                                                    Statement::Return(Return::new(Some(
+                                                        Literal::from(1).into(),
+                                                    ))),
+                                                )]
                                                 .into(),
+                                            ),
                                             false,
                                         )
                                         .into(),
@@ -84,6 +91,7 @@ fn check_nested_async_generator_expr() {
                             ))
                             .into()]
                             .into(),
+                        ),
                         false,
                     )
                     .into(),

boa_parser/src/parser/expression/primary/function_expression/mod.rs

@@ -22,7 +22,7 @@ use crate::{
 use boa_ast::{
     expression::Identifier,
     function::Function,
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
     Keyword, Punctuator,
 };
 use boa_interner::{Interner, Sym};
@@ -135,7 +135,7 @@ where
         // https://tc39.es/ecma262/#sec-function-definitions-static-semantics-early-errors
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;

boa_parser/src/parser/expression/primary/function_expression/tests.rs

@@ -2,7 +2,7 @@ use crate::parser::tests::check_script_parser;
 use boa_ast::{
     declaration::{LexicalDeclaration, Variable},
     expression::literal::Literal,
-    function::{FormalParameterList, Function},
+    function::{FormalParameterList, Function, FunctionBody},
     statement::Return,
     Declaration, Statement, StatementListItem,
 };
@@ -26,10 +26,12 @@ fn check_function_expression() {
                     Function::new(
                         Some(add.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(Literal::from(1).into())),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -61,6 +63,7 @@ fn check_nested_function_expression() {
                     Function::new(
                         Some(a.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![Declaration::Lexical(LexicalDeclaration::Const(
                                 vec![Variable::from_identifier(
                                     b.into(),
@@ -68,10 +71,14 @@ fn check_nested_function_expression() {
                                         Function::new(
                                             Some(b.into()),
                                             FormalParameterList::default(),
-                                        vec![StatementListItem::Statement(Statement::Return(
+                                            FunctionBody::new(
-                                            Return::new(Some(Literal::from(1).into())),
+                                                vec![StatementListItem::Statement(
-                                        ))]
+                                                    Statement::Return(Return::new(Some(
+                                                        Literal::from(1).into(),
+                                                    ))),
+                                                )]
                                                 .into(),
+                                            ),
                                         )
                                         .into(),
                                     ),
@@ -81,6 +88,7 @@ fn check_nested_function_expression() {
                             ))
                             .into()]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -104,7 +112,15 @@ fn check_function_non_reserved_keyword() {
                         Function::new_with_binding_identifier(
                             Some($interner.get_or_intern_static($keyword, utf16!($keyword)).into()),
                             FormalParameterList::default(),
-                            vec![StatementListItem::Statement(Statement::Return(Return::new(Some(Literal::from(1).into()))))].into(),
+                            FunctionBody::new(
+                                vec![StatementListItem::Statement(
+                                    Statement::Return(
+                                        Return::new(
+                                            Some(Literal::from(1).into())
+                                        )
+                                    )
+                                )].into()
+                            ),
                             true,
                         )
                         .into(),

boa_parser/src/parser/expression/primary/generator_expression/mod.rs

@@ -22,7 +22,7 @@ use crate::{
 use boa_ast::{
     expression::Identifier,
     function::Generator,
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
     Keyword, Punctuator,
 };
 use boa_interner::{Interner, Sym};
@@ -143,7 +143,7 @@ where
         // https://tc39.es/ecma262/#sec-generator-function-definitions-static-semantics-early-errors
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;

boa_parser/src/parser/expression/primary/generator_expression/tests.rs

@@ -2,7 +2,7 @@ use crate::parser::tests::check_script_parser;
 use boa_ast::{
     declaration::{LexicalDeclaration, Variable},
     expression::{literal::Literal, Yield},
-    function::{FormalParameterList, Generator},
+    function::{FormalParameterList, FunctionBody, Generator},
     Declaration, Expression, Statement, StatementListItem,
 };
 use boa_interner::Interner;
@@ -24,10 +24,12 @@ fn check_generator_function_expression() {
                     Generator::new(
                         Some(gen.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Expression(
                                 Expression::from(Yield::new(Some(Literal::from(1).into()), false)),
                             ))]
                             .into(),
+                        ),
                         false,
                     )
                     .into(),
@@ -57,10 +59,12 @@ fn check_generator_function_delegate_yield_expression() {
                     Generator::new(
                         Some(gen.into()),
                         FormalParameterList::default(),
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Expression(
                                 Expression::from(Yield::new(Some(Literal::from(1).into()), true)),
                             ))]
                             .into(),
+                        ),
                         false,
                     )
                     .into(),

boa_parser/src/parser/expression/primary/object_initializer/mod.rs

@@ -32,7 +32,7 @@ use boa_ast::{
         AsyncFunction, AsyncGenerator, FormalParameterList, Function, Generator, PrivateName,
     },
     operations::{
-        bound_names, contains, has_direct_super, top_level_lexically_declared_names, ContainsSymbol,
+        bound_names, contains, has_direct_super, lexically_declared_names, ContainsSymbol,
     },
     property::{self, MethodDefinition},
     Expression, Keyword, Punctuator,
@@ -442,7 +442,7 @@ where
                 // https://tc39.es/ecma262/#sec-method-definitions-static-semantics-early-errors
                 name_in_lexically_declared_names(
                     &bound_names(&parameters),
-                    &top_level_lexically_declared_names(&body),
+                    &lexically_declared_names(&body),
                     params_start_position,
                     interner,
                 )?;
@@ -518,7 +518,7 @@ where
                 // LexicallyDeclaredNames of FunctionBody.
                 name_in_lexically_declared_names(
                     &bound_names(&params),
-                    &top_level_lexically_declared_names(&body),
+                    &lexically_declared_names(&body),
                     params_start_position,
                     interner,
                 )?;
@@ -801,7 +801,7 @@ where
         // occurs in the LexicallyDeclaredNames of GeneratorBody.
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;
@@ -917,7 +917,7 @@ where
         // occurs in the LexicallyDeclaredNames of GeneratorBody.
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;
@@ -1010,7 +1010,7 @@ where
         // occurs in the LexicallyDeclaredNames of GeneratorBody.
         name_in_lexically_declared_names(
             &bound_names(&params),
-            &top_level_lexically_declared_names(&body),
+            &lexically_declared_names(&body),
             params_start_position,
             interner,
         )?;

boa_parser/src/parser/expression/primary/object_initializer/tests.rs

@@ -7,10 +7,10 @@ use boa_ast::{
     },
     function::{
         AsyncFunction, AsyncGenerator, FormalParameter, FormalParameterList,
-        FormalParameterListFlags, Function,
+        FormalParameterListFlags, Function, FunctionBody,
     },
     property::{MethodDefinition, PropertyDefinition, PropertyName},
-    Declaration, StatementList,
+    Declaration,
 };
 use boa_interner::{Interner, Sym};
 use boa_macros::utf16;
@@ -65,7 +65,7 @@ fn check_object_short_function() {
             MethodDefinition::Ordinary(Function::new(
                 Some(interner.get_or_intern_static("b", utf16!("b")).into()),
                 FormalParameterList::default(),
-                StatementList::default(),
+                FunctionBody::default(),
             )),
         ),
     ];
@@ -115,7 +115,7 @@ fn check_object_short_function_arguments() {
             MethodDefinition::Ordinary(Function::new(
                 Some(interner.get_or_intern_static("b", utf16!("b")).into()),
                 parameters,
-                StatementList::default(),
+                FunctionBody::default(),
             )),
         ),
     ];
@@ -157,7 +157,7 @@ fn check_object_getter() {
                         .into(),
                 ),
                 FormalParameterList::default(),
-                StatementList::default(),
+                FunctionBody::default(),
             )),
         ),
     ];
@@ -210,7 +210,7 @@ fn check_object_setter() {
                         .into(),
                 ),
                 params,
-                StatementList::default(),
+                FunctionBody::default(),
             )),
         ),
     ];
@@ -243,7 +243,7 @@ fn check_object_short_function_get() {
         MethodDefinition::Ordinary(Function::new(
             Some(interner.get_or_intern_static("get", utf16!("get")).into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
         )),
     )];
 
@@ -274,7 +274,7 @@ fn check_object_short_function_set() {
         MethodDefinition::Ordinary(Function::new(
             Some(interner.get_or_intern_static("set", utf16!("set")).into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
         )),
     )];
 
@@ -422,7 +422,7 @@ fn check_async_method() {
         MethodDefinition::Async(AsyncFunction::new(
             Some(interner.get_or_intern_static("dive", utf16!("dive")).into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         )),
     )];
@@ -460,7 +460,7 @@ fn check_async_generator_method() {
                     .into(),
             ),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         )),
     )];
@@ -518,7 +518,7 @@ fn check_async_ordinary_method() {
                     .into(),
             ),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
         )),
     )];
 

boa_parser/src/parser/function/mod.rs

@@ -449,7 +449,7 @@ impl<R> TokenParser<R> for FunctionStatementList
 where
     R: Read,
 {
-    type Output = ast::StatementList;
+    type Output = ast::function::FunctionBody;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
         let _timer = Profiler::global().start_event("FunctionStatementList", "Parsing");
@@ -478,6 +478,6 @@ where
             )));
         }
 
-        Ok(statement_list)
+        Ok(ast::function::FunctionBody::new(statement_list))
     }
 }

boa_parser/src/parser/function/tests.rs

@@ -7,9 +7,10 @@ use boa_ast::{
     },
     function::{
         ArrowFunction, FormalParameter, FormalParameterList, FormalParameterListFlags, Function,
+        FunctionBody,
     },
     statement::Return,
-    Declaration, Expression, Statement, StatementList, StatementListItem,
+    Declaration, Expression, Statement, StatementListItem,
 };
 use boa_interner::Interner;
 use boa_macros::utf16;
@@ -30,12 +31,14 @@ fn check_basic() {
         vec![Declaration::Function(Function::new(
             Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(Some(
                         Identifier::from(interner.get_or_intern_static("a", utf16!("a"))).into(),
                     )),
                 ))]
                 .into(),
+            ),
         ))
         .into()],
         interner,
@@ -66,12 +69,14 @@ fn check_duplicates_strict_off() {
         vec![Declaration::Function(Function::new(
             Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(Some(
                         Identifier::from(interner.get_or_intern_static("a", utf16!("a"))).into(),
                     )),
                 ))]
                 .into(),
+            ),
         ))
         .into()],
         interner,
@@ -100,12 +105,14 @@ fn check_basic_semicolon_insertion() {
         vec![Declaration::Function(Function::new(
             Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(Some(
                         Identifier::from(interner.get_or_intern_static("a", utf16!("a"))).into(),
                     )),
                 ))]
                 .into(),
+            ),
         ))
         .into()],
         interner,
@@ -127,10 +134,12 @@ fn check_empty_return() {
         vec![Declaration::Function(Function::new(
             Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(None),
                 ))]
                 .into(),
+            ),
         ))
         .into()],
         interner,
@@ -152,10 +161,12 @@ fn check_empty_return_semicolon_insertion() {
         vec![Declaration::Function(Function::new(
             Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(None),
                 ))]
                 .into(),
+            ),
         ))
         .into()],
         interner,
@@ -186,7 +197,7 @@ fn check_rest_operator() {
         vec![Declaration::Function(Function::new(
             Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
             params,
-            StatementList::default(),
+            FunctionBody::default(),
         ))
         .into()],
         interner,
@@ -211,7 +222,7 @@ fn check_arrow_only_rest() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
-            StatementList::default(),
+            FunctionBody::default(),
         )))
         .into()],
         interner,
@@ -246,7 +257,7 @@ fn check_arrow_rest() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
-            StatementList::default(),
+            FunctionBody::default(),
         )))
         .into()],
         interner,
@@ -274,6 +285,7 @@ fn check_arrow() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(Some(
                         Binary::new(
@@ -285,6 +297,7 @@ fn check_arrow() {
                     )),
                 ))]
                 .into(),
+            ),
         )))
         .into()],
         interner,
@@ -310,6 +323,7 @@ fn check_arrow_semicolon_insertion() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(Some(
                         Binary::new(
@@ -321,6 +335,7 @@ fn check_arrow_semicolon_insertion() {
                     )),
                 ))]
                 .into(),
+            ),
         )))
         .into()],
         interner,
@@ -346,10 +361,12 @@ fn check_arrow_epty_return() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(None),
                 ))]
                 .into(),
+            ),
         )))
         .into()],
         interner,
@@ -375,10 +392,12 @@ fn check_arrow_empty_return_semicolon_insertion() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
+            FunctionBody::new(
                 vec![StatementListItem::Statement(Statement::Return(
                     Return::new(None),
                 ))]
                 .into(),
+            ),
         )))
         .into()],
         interner,
@@ -403,13 +422,17 @@ fn check_arrow_assignment() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -440,13 +463,17 @@ fn check_arrow_assignment_nobrackets() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -477,13 +504,17 @@ fn check_arrow_assignment_noparenthesis() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -514,13 +545,17 @@ fn check_arrow_assignment_noparenthesis_nobrackets() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -557,13 +592,17 @@ fn check_arrow_assignment_2arg() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -600,13 +639,17 @@ fn check_arrow_assignment_2arg_nobrackets() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -647,13 +690,17 @@ fn check_arrow_assignment_3arg() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),
@@ -694,13 +741,17 @@ fn check_arrow_assignment_3arg_nobrackets() {
                     ArrowFunction::new(
                         Some(interner.get_or_intern_static("foo", utf16!("foo")).into()),
                         params,
+                        FunctionBody::new(
                             vec![StatementListItem::Statement(Statement::Return(
                                 Return::new(Some(
-                                Identifier::new(interner.get_or_intern_static("a", utf16!("a")))
+                                    Identifier::new(
+                                        interner.get_or_intern_static("a", utf16!("a")),
+                                    )
                                     .into(),
                                 )),
                             ))]
                             .into(),
+                        ),
                     )
                     .into(),
                 ),

boa_parser/src/parser/mod.rs

@@ -20,18 +20,19 @@ use crate::{
 };
 use boa_ast::{
     expression::Identifier,
-    function::FormalParameterList,
+    function::{FormalParameterList, FunctionBody},
     operations::{
         all_private_identifiers_valid, check_labels, contains, contains_invalid_object_literal,
-        lexically_declared_names, top_level_lexically_declared_names, top_level_var_declared_names,
+        lexically_declared_names, var_declared_names, ContainsSymbol,
-        var_declared_names, ContainsSymbol,
     },
-    ModuleItemList, Position, StatementList,
+    Position, StatementList,
 };
 use boa_interner::Interner;
 use rustc_hash::FxHashSet;
 use std::{io::Read, path::Path};
 
+use self::statement::ModuleItemList;
+
 /// Trait implemented by parsers.
 ///
 /// This makes it possible to abstract over the underlying implementation of a parser.
@@ -126,15 +127,15 @@ impl<'a, R: Read> Parser<'a, R> {
     }
 
     /// Parse the full input as a [ECMAScript Script][spec] into the boa AST representation.
-    /// The resulting `StatementList` can be compiled into boa bytecode and executed in the boa vm.
+    /// The resulting `Script` can be compiled into boa bytecode and executed in the boa vm.
     ///
     /// # Errors
     ///
     /// Will return `Err` on any parsing error, including invalid reads of the bytes being parsed.
     ///
     /// [spec]: https://tc39.es/ecma262/#prod-Script
-    pub fn parse_script(&mut self, interner: &mut Interner) -> ParseResult<StatementList> {
+    pub fn parse_script(&mut self, interner: &mut Interner) -> ParseResult<boa_ast::Script> {
-        Script::new(false).parse(&mut self.cursor, interner)
+        ScriptParser::new(false).parse(&mut self.cursor, interner)
     }
 
     /// Parse the full input as an [ECMAScript Module][spec] into the boa AST representation.
@@ -145,11 +146,11 @@ impl<'a, R: Read> Parser<'a, R> {
     /// Will return `Err` on any parsing error, including invalid reads of the bytes being parsed.
     ///
     /// [spec]: https://tc39.es/ecma262/#prod-Module
-    pub fn parse_module(&mut self, interner: &mut Interner) -> ParseResult<ModuleItemList>
+    pub fn parse_module(&mut self, interner: &mut Interner) -> ParseResult<boa_ast::Module>
     where
         R: Read,
     {
-        Module.parse(&mut self.cursor, interner)
+        ModuleParser.parse(&mut self.cursor, interner)
     }
 
     /// [`19.2.1.1 PerformEval ( x, strictCaller, direct )`][spec]
@@ -165,8 +166,8 @@ impl<'a, R: Read> Parser<'a, R> {
         &mut self,
         direct: bool,
         interner: &mut Interner,
-    ) -> ParseResult<StatementList> {
+    ) -> ParseResult<boa_ast::Script> {
-        Script::new(direct).parse(&mut self.cursor, interner)
+        ScriptParser::new(direct).parse(&mut self.cursor, interner)
     }
 
     /// Parses the full input as an [ECMAScript `FunctionBody`][spec] into the boa AST representation.
@@ -181,7 +182,7 @@ impl<'a, R: Read> Parser<'a, R> {
         interner: &mut Interner,
         allow_yield: bool,
         allow_await: bool,
-    ) -> ParseResult<StatementList> {
+    ) -> ParseResult<FunctionBody> {
         FunctionStatementList::new(allow_yield, allow_await).parse(&mut self.cursor, interner)
     }
 
@@ -235,11 +236,11 @@ impl<R> Parser<'_, R> {
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-Script
 #[derive(Debug, Clone, Copy)]
-pub struct Script {
+pub struct ScriptParser {
     direct_eval: bool,
 }
 
-impl Script {
+impl ScriptParser {
     /// Create a new `Script` parser.
     #[inline]
     const fn new(direct_eval: bool) -> Self {
@@ -247,19 +248,20 @@ impl Script {
     }
 }
 
-impl<R> TokenParser<R> for Script
+impl<R> TokenParser<R> for ScriptParser
 where
     R: Read,
 {
-    type Output = StatementList;
+    type Output = boa_ast::Script;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
-        let statement_list =
+        let script = boa_ast::Script::new(
-            ScriptBody::new(true, cursor.strict(), self.direct_eval).parse(cursor, interner)?;
+            ScriptBody::new(true, cursor.strict(), self.direct_eval).parse(cursor, interner)?,
+        );
 
         // It is a Syntax Error if the LexicallyDeclaredNames of ScriptBody contains any duplicate entries.
         let mut lexical_names = FxHashSet::default();
-        for name in top_level_lexically_declared_names(&statement_list) {
+        for name in lexically_declared_names(&script) {
             if !lexical_names.insert(name) {
                 return Err(Error::general(
                     "lexical name declared multiple times",
@@ -269,7 +271,7 @@ where
         }
 
         // It is a Syntax Error if any element of the LexicallyDeclaredNames of ScriptBody also occurs in the VarDeclaredNames of ScriptBody.
-        for name in top_level_var_declared_names(&statement_list) {
+        for name in var_declared_names(&script) {
             if lexical_names.contains(&name) {
                 return Err(Error::general(
                     "lexical name declared multiple times",
@@ -278,7 +280,7 @@ where
             }
         }
 
-        Ok(statement_list)
+        Ok(script)
     }
 }
 
@@ -370,39 +372,6 @@ where
     }
 }
 
-/// Helper to check if any parameter names are declared in the given list.
-fn name_in_lexically_declared_names(
-    bound_names: &[Identifier],
-    lexical_names: &[Identifier],
-    position: Position,
-    interner: &Interner,
-) -> ParseResult<()> {
-    for name in bound_names {
-        if lexical_names.contains(name) {
-            return Err(Error::general(
-                format!(
-                    "formal parameter `{}` declared in lexically declared names",
-                    interner.resolve_expect(name.sym())
-                ),
-                position,
-            ));
-        }
-    }
-    Ok(())
-}
-
-/// Trait to reduce boilerplate in the parser.
-trait OrAbrupt<T> {
-    /// Will convert an `Ok(None)` to an [`Error::AbruptEnd`] or return the inner type if not.
-    fn or_abrupt(self) -> ParseResult<T>;
-}
-
-impl<T> OrAbrupt<T> for ParseResult<Option<T>> {
-    fn or_abrupt(self) -> ParseResult<T> {
-        self?.ok_or(Error::AbruptEnd)
-    }
-}
-
 /// Parses a full module.
 ///
 /// More information:
@@ -410,26 +379,22 @@ impl<T> OrAbrupt<T> for ParseResult<Option<T>> {
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-Module
 #[derive(Debug, Clone, Copy)]
-struct Module;
+struct ModuleParser;
 
-impl<R> TokenParser<R> for Module
+impl<R> TokenParser<R> for ModuleParser
 where
     R: Read,
 {
-    type Output = ModuleItemList;
+    type Output = boa_ast::Module;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
         cursor.set_module();
 
-        let items = if cursor.peek(0, interner)?.is_some() {
+        let module = boa_ast::Module::new(ModuleItemList.parse(cursor, interner)?);
-            self::statement::ModuleItemList.parse(cursor, interner)?
-        } else {
-            return Ok(Vec::new().into());
-        };
 
         // It is a Syntax Error if the LexicallyDeclaredNames of ModuleItemList contains any duplicate entries.
         let mut bindings = FxHashSet::default();
-        for name in lexically_declared_names(&items) {
+        for name in lexically_declared_names(&module) {
             if !bindings.insert(name) {
                 return Err(Error::general(
                     format!(
@@ -443,7 +408,7 @@ where
 
         // It is a Syntax Error if any element of the LexicallyDeclaredNames of ModuleItemList also occurs in the
         // VarDeclaredNames of ModuleItemList.
-        for name in var_declared_names(&items) {
+        for name in var_declared_names(&module) {
             if !bindings.insert(name) {
                 return Err(Error::general(
                     format!(
@@ -458,7 +423,7 @@ where
         // It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries.
         {
             let mut exported_names = FxHashSet::default();
-            for name in items.exported_names() {
+            for name in module.items().exported_names() {
                 if !exported_names.insert(name) {
                     return Err(Error::general(
                         format!(
@@ -473,7 +438,7 @@ where
 
         // It is a Syntax Error if any element of the ExportedBindings of ModuleItemList does not also occur in either
         // the VarDeclaredNames of ModuleItemList, or the LexicallyDeclaredNames of ModuleItemList.
-        for name in items.exported_bindings() {
+        for name in module.items().exported_bindings() {
             if !bindings.contains(&name) {
                 return Err(Error::general(
                     format!(
@@ -486,7 +451,7 @@ where
         }
 
         // It is a Syntax Error if ModuleItemList Contains super.
-        if contains(&items, ContainsSymbol::Super) {
+        if contains(&module, ContainsSymbol::Super) {
             return Err(Error::general(
                 "module cannot contain `super` on the top-level",
                 Position::new(1, 1),
@@ -494,19 +459,64 @@ where
         }
 
         // It is a Syntax Error if ModuleItemList Contains NewTarget.
-        if contains(&items, ContainsSymbol::NewTarget) {
+        if contains(&module, ContainsSymbol::NewTarget) {
             return Err(Error::general(
                 "module cannot contain `new.target` on the top-level",
                 Position::new(1, 1),
             ));
         }
 
-        // TODO:
         // It is a Syntax Error if ContainsDuplicateLabels of ModuleItemList with argument « » is true.
         // It is a Syntax Error if ContainsUndefinedBreakTarget of ModuleItemList with argument « » is true.
         // It is a Syntax Error if ContainsUndefinedContinueTarget of ModuleItemList with arguments « » and « » is true.
+        check_labels(&module).map_err(|error| {
+            Error::lex(LexError::Syntax(
+                error.message(interner).into(),
+                Position::new(1, 1),
+            ))
+        })?;
+
         // It is a Syntax Error if AllPrivateIdentifiersValid of ModuleItemList with argument « » is false.
+        if !all_private_identifiers_valid(&module, Vec::new()) {
+            return Err(Error::general(
+                "invalid private identifier usage",
+                Position::new(1, 1),
+            ));
+        }
+
+        Ok(module)
+    }
+}
+
+/// Helper to check if any parameter names are declared in the given list.
+fn name_in_lexically_declared_names(
+    bound_names: &[Identifier],
+    lexical_names: &[Identifier],
+    position: Position,
+    interner: &Interner,
+) -> ParseResult<()> {
+    for name in bound_names {
+        if lexical_names.contains(name) {
+            return Err(Error::general(
+                format!(
+                    "formal parameter `{}` declared in lexically declared names",
+                    interner.resolve_expect(name.sym())
+                ),
+                position,
+            ));
+        }
+    }
+    Ok(())
+}
 
-        Ok(items)
+/// Trait to reduce boilerplate in the parser.
+trait OrAbrupt<T> {
+    /// Will convert an `Ok(None)` to an [`Error::AbruptEnd`] or return the inner type if not.
+    fn or_abrupt(self) -> ParseResult<T>;
+}
+
+impl<T> OrAbrupt<T> for ParseResult<Option<T>> {
+    fn or_abrupt(self) -> ParseResult<T> {
+        self?.ok_or(Error::AbruptEnd)
     }
 }

boa_parser/src/parser/statement/block/tests.rs

@@ -12,7 +12,7 @@ use boa_ast::{
         },
         Call, Identifier,
     },
-    function::{FormalParameterList, Function},
+    function::{FormalParameterList, Function, FunctionBody},
     statement::{Block, Return},
     Declaration, Expression, Statement, StatementListItem,
 };
@@ -81,10 +81,12 @@ fn non_empty() {
             Declaration::Function(Function::new(
                 Some(hello.into()),
                 FormalParameterList::default(),
+                FunctionBody::new(
                     vec![StatementListItem::Statement(Statement::Return(
                         Return::new(Some(Literal::from(10).into())),
                     ))]
                     .into(),
+                ),
             ))
             .into(),
             Statement::Var(VarDeclaration(
@@ -136,10 +138,12 @@ fn hoisting() {
             Declaration::Function(Function::new(
                 Some(hello.into()),
                 FormalParameterList::default(),
+                FunctionBody::new(
                     vec![StatementListItem::Statement(Statement::Return(
                         Return::new(Some(Literal::from(10).into())),
                     ))]
                     .into(),
+                ),
             ))
             .into(),
         ],

boa_parser/src/parser/statement/declaration/export.rs

@@ -59,7 +59,7 @@ where
 
                 let next = cursor.peek(0, interner).or_abrupt()?;
 
-                match next.kind() {
+                let export = match next.kind() {
                     TokenKind::IdentifierName((Sym::AS, _)) => {
                         cursor.advance(interner);
                         let tok = cursor.next(interner).or_abrupt()?;
@@ -67,9 +67,10 @@ where
                         let alias = match tok.kind() {
                             TokenKind::StringLiteral((export_name, _))
                             | TokenKind::IdentifierName((export_name, _)) => *export_name,
+                            TokenKind::Keyword((kw, _)) => kw.to_sym(),
                             _ => {
                                 return Err(Error::expected(
-                                    ["identifier".to_owned(), "string literal".to_owned()],
+                                    ["identifier name".to_owned(), "string literal".to_owned()],
                                     tok.to_string(interner),
                                     tok.span(),
                                     "export declaration",
@@ -102,7 +103,11 @@ where
                             "export declaration",
                         ))
                     }
-                }
+                };
+
+                cursor.expect_semicolon("star re-export", interner)?;
+
+                export
             }
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
                 let names = NamedExports.parse(cursor, interner)?;
@@ -115,11 +120,16 @@ where
                 ) {
                     let specifier =
                         FromClause::new("export declaration").parse(cursor, interner)?;
+
+                    cursor.expect_semicolon("named re-exports", interner)?;
+
                     AstExportDeclaration::ReExport {
                         kind: ReExportKind::Named { names },
                         specifier,
                     }
                 } else {
+                    cursor.expect_semicolon("named exports", interner)?;
+
                     AstExportDeclaration::List(names)
                 }
             }
@@ -165,10 +175,14 @@ where
                             ClassDeclaration::new(false, true, true).parse(cursor, interner)?,
                         )
                     }
-                    _ => AstExportDeclaration::DefaultAssignmentExpression(
+                    _ => {
-                        AssignmentExpression::new(None, true, false, true)
+                        let expr = AssignmentExpression::new(None, true, false, true)
-                            .parse(cursor, interner)?,
+                            .parse(cursor, interner)?;
-                    ),
+
+                        cursor.expect_semicolon("default expression export", interner)?;
+
+                        AstExportDeclaration::DefaultAssignmentExpression(expr)
+                    }
                 }
             }
             _ => AstExportDeclaration::Declaration(
@@ -222,7 +236,9 @@ where
                     }
                     cursor.advance(interner);
                 }
-                TokenKind::StringLiteral(_) | TokenKind::IdentifierName(_) => {
+                TokenKind::StringLiteral(_)
+                | TokenKind::IdentifierName(_)
+                | TokenKind::Keyword(_) => {
                     list.push(ExportSpecifier.parse(cursor, interner)?);
                 }
                 _ => {
@@ -272,6 +288,7 @@ where
                 Ok(*ident)
             }
             TokenKind::IdentifierName((ident, _)) => Ok(*ident),
+            TokenKind::Keyword((kw, _)) => Ok(kw.to_sym()),
             _ => Err(Error::expected(
                 ["identifier".to_owned(), "string literal".to_owned()],
                 tok.to_string(interner),

boa_parser/src/parser/statement/declaration/hoistable/async_function_decl/tests.rs

@@ -1,7 +1,7 @@
 use crate::parser::tests::check_script_parser;
 use boa_ast::{
-    function::{AsyncFunction, FormalParameterList},
+    function::{AsyncFunction, FormalParameterList, FunctionBody},
-    Declaration, StatementList,
+    Declaration,
 };
 use boa_interner::{Interner, Sym};
 use boa_macros::utf16;
@@ -19,7 +19,7 @@ fn async_function_declaration() {
                     .into(),
             ),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         ))
         .into()],
@@ -36,7 +36,7 @@ fn async_function_declaration_keywords() {
         vec![Declaration::AsyncFunction(AsyncFunction::new(
             Some(Sym::YIELD.into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         ))
         .into()],
@@ -49,7 +49,7 @@ fn async_function_declaration_keywords() {
         vec![Declaration::AsyncFunction(AsyncFunction::new(
             Some(Sym::AWAIT.into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         ))
         .into()],

boa_parser/src/parser/statement/declaration/hoistable/async_generator_decl/tests.rs

@@ -1,7 +1,7 @@
 use crate::parser::tests::check_script_parser;
 use boa_ast::{
-    function::{AsyncGenerator, FormalParameterList},
+    function::{AsyncGenerator, FormalParameterList, FunctionBody},
-    Declaration, StatementList,
+    Declaration,
 };
 use boa_interner::Interner;
 use boa_macros::utf16;
@@ -14,7 +14,7 @@ fn async_generator_function_declaration() {
         vec![Declaration::AsyncGenerator(AsyncGenerator::new(
             Some(interner.get_or_intern_static("gen", utf16!("gen")).into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         ))
         .into()],

boa_parser/src/parser/statement/declaration/hoistable/class_decl/mod.rs

@@ -696,7 +696,9 @@ where
                     cursor.set_strict(strict);
                     statement_list
                 };
-                function::ClassElement::StaticBlock(statement_list)
+                function::ClassElement::StaticBlock(ast::function::FunctionBody::new(
+                    statement_list,
+                ))
             }
             TokenKind::Punctuator(Punctuator::Mul) => {
                 let token = cursor.peek(1, interner).or_abrupt()?;
@@ -1346,7 +1348,7 @@ where
             }
             // ClassStaticBlockBody : ClassStaticBlockStatementList
             function::ClassElement::StaticBlock(block) => {
-                for node in block.statements() {
+                for node in &**block.statements() {
                     // It is a Syntax Error if ContainsArguments of ClassStaticBlockStatementList is true.
                     if contains_arguments(node) {
                         return Err(Error::general(

boa_parser/src/parser/statement/declaration/hoistable/class_decl/tests.rs

@@ -6,7 +6,7 @@ use boa_ast::{
         literal::Literal,
         Call, Identifier,
     },
-    function::{Class, ClassElement, FormalParameterList, Function},
+    function::{Class, ClassElement, FormalParameterList, Function, FunctionBody},
     property::{MethodDefinition, PropertyName},
     Declaration, Expression, Statement, StatementList, StatementListItem,
 };
@@ -22,7 +22,7 @@ fn check_async_ordinary_method() {
         MethodDefinition::Ordinary(Function::new(
             None,
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
         )),
     )];
 
@@ -120,7 +120,10 @@ fn check_new_target_with_property_access() {
     let constructor = Function::new(
         Some(interner.get_or_intern_static("A", utf16!("A")).into()),
         FormalParameterList::default(),
-        StatementList::new([Statement::Expression(console).into()], false),
+        FunctionBody::new(StatementList::new(
+            [Statement::Expression(console).into()],
+            false,
+        )),
     );
 
     let class = Class::new(

boa_parser/src/parser/statement/declaration/hoistable/function_decl/tests.rs

@@ -1,7 +1,7 @@
 use crate::parser::tests::check_script_parser;
 use boa_ast::{
-    function::{FormalParameterList, Function},
+    function::{FormalParameterList, Function, FunctionBody},
-    Declaration, StatementList,
+    Declaration,
 };
 use boa_interner::Interner;
 use boa_macros::utf16;
@@ -19,7 +19,7 @@ fn function_declaration() {
                     .into(),
             ),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
         ))
         .into()],
         interner,
@@ -38,7 +38,7 @@ fn function_declaration_keywords() {
                         .into(),
                 ),
                 FormalParameterList::default(),
-                StatementList::default(),
+                FunctionBody::default(),
             ))
             .into()]
         };

boa_parser/src/parser/statement/declaration/hoistable/generator_decl/tests.rs

@@ -1,7 +1,7 @@
 use crate::parser::tests::check_script_parser;
 use boa_ast::{
-    function::{FormalParameterList, Generator},
+    function::{FormalParameterList, FunctionBody, Generator},
-    Declaration, StatementList,
+    Declaration,
 };
 use boa_interner::Interner;
 use boa_macros::utf16;
@@ -14,7 +14,7 @@ fn generator_function_declaration() {
         vec![Declaration::Generator(Generator::new(
             Some(interner.get_or_intern_static("gen", utf16!("gen")).into()),
             FormalParameterList::default(),
-            StatementList::default(),
+            FunctionBody::default(),
             false,
         ))
         .into()],

boa_parser/src/parser/statement/declaration/hoistable/mod.rs

@@ -27,10 +27,11 @@ use crate::{
     Error,
 };
 use boa_ast::{
+    self as ast,
     expression::Identifier,
     function::FormalParameterList,
-    operations::{bound_names, contains, top_level_lexically_declared_names, ContainsSymbol},
+    operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
-    Declaration, Keyword, Punctuator, StatementList,
+    Declaration, Keyword, Punctuator,
 };
 use boa_interner::{Interner, Sym};
 use boa_profiler::Profiler;
@@ -148,7 +149,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     c: &C,
     cursor: &mut Cursor<R>,
     interner: &mut Interner,
-) -> ParseResult<(Identifier, FormalParameterList, StatementList)> {
+) -> ParseResult<(Identifier, FormalParameterList, ast::function::FunctionBody)> {
     let token = cursor.peek(0, interner).or_abrupt()?;
     let name_span = token.span();
     let name = match token.kind() {
@@ -222,7 +223,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     // also occurs in the LexicallyDeclaredNames of FunctionBody.
     name_in_lexically_declared_names(
         &bound_names(&params),
-        &top_level_lexically_declared_names(&body),
+        &lexically_declared_names(&body),
         params_start_position,
         interner,
     )?;

boa_parser/src/parser/statement/declaration/import.rs

@@ -38,6 +38,39 @@ use std::io::Read;
 #[derive(Debug, Clone, Copy)]
 pub(in crate::parser) struct ImportDeclaration;
 
+impl ImportDeclaration {
+    /// Tests if the next node is an `ImportDeclaration`.
+    pub(in crate::parser) fn test<R: Read>(
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> ParseResult<bool> {
+        if let Some(token) = cursor.peek(0, interner)? {
+            if let TokenKind::Keyword((Keyword::Import, escaped)) = token.kind() {
+                if *escaped {
+                    return Err(Error::general(
+                        "keyword `import` must not contain escaped characters",
+                        token.span().start(),
+                    ));
+                }
+
+                if let Some(token) = cursor.peek(1, interner)? {
+                    match token.kind() {
+                        TokenKind::StringLiteral(_)
+                        | TokenKind::Punctuator(Punctuator::OpenBlock | Punctuator::Mul)
+                        | TokenKind::IdentifierName(_)
+                        | TokenKind::Keyword((Keyword::Await | Keyword::Yield, _)) => {
+                            return Ok(true)
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+
+        Ok(false)
+    }
+}
+
 impl<R> TokenParser<R> for ImportDeclaration
 where
     R: Read,

boa_parser/src/parser/statement/mod.rs

@@ -961,12 +961,20 @@ where
         let tok = cursor.peek(0, interner).or_abrupt()?;
 
         match tok.kind() {
-            TokenKind::Keyword((Keyword::Import, false)) => ImportDeclaration
-                .parse(cursor, interner)
-                .map(Self::Output::ImportDeclaration),
             TokenKind::Keyword((Keyword::Export, false)) => ExportDeclaration
                 .parse(cursor, interner)
                 .map(Self::Output::ExportDeclaration),
+            TokenKind::Keyword((Keyword::Import, false)) => {
+                if ImportDeclaration::test(cursor, interner)? {
+                    ImportDeclaration
+                        .parse(cursor, interner)
+                        .map(Self::Output::ImportDeclaration)
+                } else {
+                    StatementListItem::new(false, true, false)
+                        .parse(cursor, interner)
+                        .map(Self::Output::StatementListItem)
+                }
+            }
             _ => StatementListItem::new(false, true, false)
                 .parse(cursor, interner)
                 .map(Self::Output::StatementListItem),

boa_parser/src/parser/tests/mod.rs

@@ -20,10 +20,11 @@ use boa_ast::{
     },
     function::{
         ArrowFunction, FormalParameter, FormalParameterList, FormalParameterListFlags, Function,
+        FunctionBody,
     },
     property::PropertyDefinition,
     statement::{If, Return},
-    Expression, Statement, StatementList, StatementListItem,
+    Expression, Script, Statement, StatementList, StatementListItem,
 };
 use boa_interner::Interner;
 use boa_macros::utf16;
@@ -39,7 +40,7 @@ where
         Parser::new(Source::from_bytes(js))
             .parse_script(interner)
             .expect("failed to parse"),
-        StatementList::from(expr.into())
+        Script::new(StatementList::from(expr.into()))
     );
 }
 
@@ -126,7 +127,10 @@ fn hoisting() {
             Declaration::Function(Function::new(
                 Some(hello.into()),
                 FormalParameterList::default(),
-                vec![Statement::Return(Return::new(Some(Literal::from(10).into()))).into()].into(),
+                FunctionBody::new(
+                    vec![Statement::Return(Return::new(Some(Literal::from(10).into()))).into()]
+                        .into(),
+                ),
             ))
             .into(),
         ],
@@ -505,7 +509,9 @@ fn spread_in_arrow_function() {
         vec![Statement::Expression(Expression::from(ArrowFunction::new(
             None,
             params,
+            FunctionBody::new(
                 vec![Statement::Expression(Expression::from(Identifier::from(b))).into()].into(),
+            ),
         )))
         .into()],
         interner,

boa_runtime/src/lib.rs

@@ -24,7 +24,7 @@
 //! let js_code = "console.log('Hello World from a JS code string!')";
 //!
 //! // Parse the source code
-//! match context.eval_script(Source::from_bytes(js_code)) {
+//! match context.eval(Source::from_bytes(js_code)) {
 //!     Ok(res) => {
 //!         println!(
 //!             "{}",
@@ -186,7 +186,7 @@ pub(crate) mod test {
     ) {
         #[track_caller]
         fn forward_val(context: &mut Context<'_>, source: &str) -> JsResult<JsValue> {
-            context.eval_script(Source::from_bytes(source))
+            context.eval(Source::from_bytes(source))
         }
 
         #[track_caller]

boa_tester/src/edition.rs

@@ -91,10 +91,6 @@ static FEATURE_EDITION: phf::Map<&'static str, SpecEdition> = phf::phf_map! {
     // https://github.com/tc39/proposal-duplicate-named-capturing-groups
     "regexp-duplicate-named-groups" => SpecEdition::ESNext,
 
-    // Symbols as WeakMap keys
-    // https://github.com/tc39/proposal-symbols-as-weakmap-keys
-    "symbols-as-weakmap-keys" => SpecEdition::ESNext,
-
     // Array.prototype.toReversed, Array.prototype.toSorted, Array.prototype.toSpliced,
     // Array.prototype.with and the equivalent TypedArray methods.
     // https://github.com/tc39/proposal-change-array-by-copy/
@@ -116,6 +112,7 @@ static FEATURE_EDITION: phf::Map<&'static str, SpecEdition> = phf::phf_map! {
     "Intl.DateTimeFormat-extend-timezonename" => SpecEdition::ESNext,
     "Intl.DisplayNames-v2" => SpecEdition::ESNext,
     "Intl.Segmenter" => SpecEdition::ESNext,
+    "symbols-as-weakmap-keys" => SpecEdition::ESNext,
 
     // Standard language features
 

boa_tester/src/exec/js262.rs

@@ -92,17 +92,7 @@ fn detach_array_buffer(_: &JsValue, args: &[JsValue], _: &mut Context<'_>) -> Js
 fn eval_script(_this: &JsValue, args: &[JsValue], context: &mut Context<'_>) -> JsResult<JsValue> {
     args.get(0).and_then(JsValue::as_string).map_or_else(
         || Ok(JsValue::undefined()),
-        |source_text| match context
+        |source_text| context.eval(Source::from_bytes(&source_text.to_std_string_escaped())),
-            .parse_script(Source::from_bytes(&source_text.to_std_string_escaped()))
-        {
-            // TODO: check strict
-            Err(e) => Err(JsNativeError::typ()
-                .with_message(format!("Uncaught Syntax Error: {e}"))
-                .into()),
-            // Calling eval here parses the code a second time.
-            // TODO: We can fix this after we have have defined the public api for the vm executer.
-            Ok(_) => context.eval_script(Source::from_bytes(&source_text.to_std_string_escaped())),
-        },
     )
 }
 

boa_tester/src/exec/mod.rs

@@ -13,12 +13,13 @@ use boa_engine::{
     object::FunctionObjectBuilder,
     optimizer::OptimizerOptions,
     property::Attribute,
+    script::Script,
     Context, JsArgs, JsError, JsNativeErrorKind, JsValue, Source,
 };
 use colored::Colorize;
 use fxhash::FxHashSet;
 use rayon::prelude::*;
-use std::{cell::RefCell, rc::Rc};
+use std::{cell::RefCell, eprintln, rc::Rc};
 
 impl TestSuite {
     /// Runs the test suite.
@@ -264,12 +265,26 @@ impl Test {
                         }
                         PromiseState::Fulfilled(v) => v,
                         PromiseState::Rejected(err) => {
-                            return (false, format!("Uncaught {}", err.display()))
+                            let output = JsError::from_opaque(err.clone())
+                                .try_native(context)
+                                .map_or_else(
+                                    |_| format!("Uncaught {}", err.display()),
+                                    |err| {
+                                        format!(
+                                            "Uncaught {err}{}",
+                                            err.cause().map_or_else(String::new, |cause| format!(
+                                                "\n  caused by {cause}"
+                                            ))
+                                        )
+                                    },
+                                );
+
+                            return (false, output);
                         }
                     }
                 } else {
                     context.strict(strict);
-                    match context.eval_script(source) {
+                    match context.eval(source) {
                         Ok(v) => v,
                         Err(err) => return (false, format!("Uncaught {err}")),
                     }
@@ -312,7 +327,7 @@ impl Test {
                     }
                 } else {
                     context.strict(strict);
-                    match context.parse_script(source) {
+                    match Script::parse(source, None, context) {
                         Ok(_) => (false, "StatementList parsing should fail".to_owned()),
                         Err(e) => (true, format!("Uncaught {e}")),
                     }
@@ -431,6 +446,8 @@ impl Test {
 
                     let promise = module.evaluate(context);
 
+                    context.run_jobs();
+
                     match promise
                         .state()
                         .expect("tester can only use builtin promises")
@@ -443,15 +460,12 @@ impl Test {
                     }
                 } else {
                     context.strict(strict);
-                    let script = match context.parse_script(source) {
+                    let script = match Script::parse(source, None, context) {
                         Ok(code) => code,
                         Err(e) => return (false, format!("Uncaught {e}")),
                     };
 
-                    match context
+                    match script.evaluate(context) {
-                        .compile_script(&script)
-                        .and_then(|code| context.execute(code))
-                    {
                         Ok(_) => return (false, "Script execution should fail".to_owned()),
                         Err(e) => e,
                     }
@@ -545,10 +559,10 @@ impl Test {
         let sta = Source::from_reader(harness.sta.content.as_bytes(), Some(&harness.sta.path));
 
         context
-            .eval_script(assert)
+            .eval(assert)
             .map_err(|e| format!("could not run assert.js:\n{e}"))?;
         context
-            .eval_script(sta)
+            .eval(sta)
             .map_err(|e| format!("could not run sta.js:\n{e}"))?;
 
         if self.flags.contains(TestFlags::ASYNC) {
@@ -557,7 +571,7 @@ impl Test {
                 Some(&harness.doneprint_handle.path),
             );
             context
-                .eval_script(dph)
+                .eval(dph)
                 .map_err(|e| format!("could not run doneprintHandle.js:\n{e}"))?;
         }
 
@@ -567,7 +581,7 @@ impl Test {
                 .get(include_name)
                 .ok_or_else(|| format!("could not find the {include_name} include file."))?;
             let source = Source::from_reader(include.content.as_bytes(), Some(&include.path));
-            context.eval_script(source).map_err(|e| {
+            context.eval(source).map_err(|e| {
                 format!("could not run the harness `{include_name}`:\nUncaught {e}",)
             })?;
         }

boa_wasm/src/lib.rs

@@ -68,7 +68,7 @@ use wasm_bindgen::prelude::*;
 pub fn evaluate(src: &str) -> Result<String, JsValue> {
     // Setup executor
     Context::default()
-        .eval_script(Source::from_bytes(src))
+        .eval(Source::from_bytes(src))
         .map_err(|e| JsValue::from(format!("Uncaught {e}")))
         .map(|v| v.display().to_string())
 }

test_ignore.toml

@@ -10,11 +10,11 @@ features = [
     "ShadowRealm",
     "FinalizationRegistry",
     "Atomics",
-    "dynamic_import",
     "decorators",
     "array-grouping",
     "IsHTMLDDA",
     "legacy-regexp",
+    "symbols-as-weakmap-keys",
 
     # Non-implemented Intl features
     "intl-normative-optional",
@@ -24,8 +24,6 @@ features = [
 
     # Stage 3 proposals
 
-    # https://github.com/tc39/proposal-symbols-as-weakmap-keys
-    "symbols-as-weakmap-keys",
     # https://github.com/tc39/proposal-intl-locale-info
     "Intl.Locale-info",
     # https://github.com/tc39/proposal-intl-enumeration