Fix remaining static module bugs (#2955)

* Fix remaining module bugs

* npx prettier

* Fix regression

.vscode/launch.json

@@ -7,7 +7,7 @@
     {
       "type": "lldb",
       "request": "launch",
-      "name": "Launch",
+      "name": "Launch (Script)",
       "windows": {
         "program": "${workspaceFolder}/target/debug/boa.exe"
       },
@@ -15,6 +15,24 @@
       "args": ["${workspaceFolder}/tests/js/test.js", "--debug-object"],
       "sourceLanguages": ["rust"],
       "preLaunchTask": "Cargo Build"
+    },
+    {
+      "type": "lldb",
+      "request": "launch",
+      "name": "Launch (Module)",
+      "windows": {
+        "program": "${workspaceFolder}/target/debug/boa.exe"
+      },
+      "program": "${workspaceFolder}/target/debug/boa",
+      "args": [
+        "${workspaceFolder}/tests/js/test.js",
+        "--debug-object",
+        "-m",
+        "-r",
+        "tests/js"
+      ],
+      "sourceLanguages": ["rust"],
+      "preLaunchTask": "Cargo Build"
     }
   ]
 }

Cargo.lock

@@ -365,6 +365,7 @@ dependencies = [
  "bitflags 2.3.1",
  "boa_interner",
  "boa_macros",
+ "indexmap",
  "num-bigint",
  "rustc-hash",
  "serde",

boa_ast/Cargo.toml

@@ -22,3 +22,4 @@ bitflags = "2.3.1"
 num-bigint = "0.4.3"
 serde = { version = "1.0.163", features = ["derive"], optional = true }
 arbitrary = { version = "1", features = ["derive"], optional = true }
+indexmap = "1.9.3"

boa_ast/src/declaration/export.rs

@@ -174,16 +174,18 @@ impl VisitWith for ExportDeclaration {
 pub struct ExportSpecifier {
     alias: Sym,
     private_name: Sym,
+    string_literal: bool,
 }
 
 impl ExportSpecifier {
     /// Creates a new [`ExportSpecifier`].
     #[inline]
     #[must_use]
-    pub const fn new(alias: Sym, private_name: Sym) -> Self {
+    pub const fn new(alias: Sym, private_name: Sym, string_literal: bool) -> Self {
         Self {
             alias,
             private_name,
+            string_literal,
         }
     }
 
@@ -200,6 +202,13 @@ impl ExportSpecifier {
     pub const fn private_name(self) -> Sym {
         self.private_name
     }
+
+    /// Returns `true` if the private name of the specifier was a `StringLiteral`.
+    #[inline]
+    #[must_use]
+    pub const fn string_literal(&self) -> bool {
+        self.string_literal
+    }
 }
 
 impl VisitWith for ExportSpecifier {

boa_ast/src/module_item_list/mod.rs

@@ -5,10 +5,11 @@
 //!
 //! [spec]: https://tc39.es/ecma262/#sec-modules
 
-use std::{convert::Infallible, ops::ControlFlow};
+use std::{convert::Infallible, hash::BuildHasherDefault, ops::ControlFlow};
 
 use boa_interner::Sym;
-use rustc_hash::FxHashSet;
+use indexmap::IndexSet;
+use rustc_hash::{FxHashSet, FxHasher};
 
 use crate::{
     declaration::{
@@ -205,9 +206,9 @@ impl ModuleItemList {
     /// [spec]: https://tc39.es/ecma262/#sec-static-semantics-modulerequests
     #[inline]
     #[must_use]
-    pub fn requests(&self) -> FxHashSet<Sym> {
+    pub fn requests(&self) -> IndexSet<Sym, BuildHasherDefault<FxHasher>> {
         #[derive(Debug)]
-        struct RequestsVisitor<'vec>(&'vec mut FxHashSet<Sym>);
+        struct RequestsVisitor<'vec>(&'vec mut IndexSet<Sym, BuildHasherDefault<FxHasher>>);
 
         impl<'ast> Visitor<'ast> for RequestsVisitor<'_> {
             type BreakTy = Infallible;
@@ -227,7 +228,7 @@ impl ModuleItemList {
             }
         }
 
-        let mut requests = FxHashSet::default();
+        let mut requests = IndexSet::default();
 
         RequestsVisitor(&mut requests).visit_module_item_list(self);
 

boa_engine/src/bytecompiler/declarations.rs

@@ -351,16 +351,16 @@ impl ByteCompiler<'_, '_> {
         for d in &declarations {
             match d {
                 LexicallyScopedDeclaration::Function(function) => {
-                    self.function(function.into(), NodeKind::Declaration, false);
+                    self.function_with_binding(function.into(), NodeKind::Declaration, false);
                 }
                 LexicallyScopedDeclaration::Generator(function) => {
-                    self.function(function.into(), NodeKind::Declaration, false);
+                    self.function_with_binding(function.into(), NodeKind::Declaration, false);
                 }
                 LexicallyScopedDeclaration::AsyncFunction(function) => {
-                    self.function(function.into(), NodeKind::Declaration, false);
+                    self.function_with_binding(function.into(), NodeKind::Declaration, false);
                 }
                 LexicallyScopedDeclaration::AsyncGenerator(function) => {
-                    self.function(function.into(), NodeKind::Declaration, false);
+                    self.function_with_binding(function.into(), NodeKind::Declaration, false);
                 }
                 _ => {}
             }
@@ -1147,7 +1147,7 @@ impl ByteCompiler<'_, '_> {
             // a. Let fn be the sole element of the BoundNames of f.
             // b. Let fo be InstantiateFunctionObject of f with arguments lexEnv and privateEnv.
             // c. Perform ! varEnv.SetMutableBinding(fn, fo, false).
-            self.function(function, NodeKind::Declaration, false);
+            self.function_with_binding(function, NodeKind::Declaration, false);
         }
 
         // 37. Return unused.

boa_engine/src/bytecompiler/env.rs

@@ -88,7 +88,7 @@ impl ByteCompiler<'_, '_> {
             .create_mutable_binding(name, function_scope));
     }
 
-    /// Initialize a mutable binding at bytecode compile time and return it's binding locator.
+    /// Initialize a mutable binding at bytecode compile time and return its binding locator.
     pub(crate) fn initialize_mutable_binding(
         &self,
         name: Identifier,

boa_engine/src/bytecompiler/expression/mod.rs

@@ -124,22 +124,22 @@ impl ByteCompiler<'_, '_> {
             }
             Expression::Spread(spread) => self.compile_expr(spread.target(), true),
             Expression::Function(function) => {
-                self.function(function.into(), NodeKind::Expression, use_expr);
+                self.function_with_binding(function.into(), NodeKind::Expression, use_expr);
             }
             Expression::ArrowFunction(function) => {
-                self.function(function.into(), NodeKind::Expression, use_expr);
+                self.function_with_binding(function.into(), NodeKind::Expression, use_expr);
             }
             Expression::AsyncArrowFunction(function) => {
-                self.function(function.into(), NodeKind::Expression, use_expr);
+                self.function_with_binding(function.into(), NodeKind::Expression, use_expr);
             }
             Expression::Generator(function) => {
-                self.function(function.into(), NodeKind::Expression, use_expr);
+                self.function_with_binding(function.into(), NodeKind::Expression, use_expr);
             }
             Expression::AsyncFunction(function) => {
-                self.function(function.into(), NodeKind::Expression, use_expr);
+                self.function_with_binding(function.into(), NodeKind::Expression, use_expr);
             }
             Expression::AsyncGenerator(function) => {
-                self.function(function.into(), NodeKind::Expression, use_expr);
+                self.function_with_binding(function.into(), NodeKind::Expression, use_expr);
             }
             Expression::Call(call) => self.call(Callable::Call(call), use_expr),
             Expression::New(new) => self.call(Callable::New(new), use_expr),

boa_engine/src/bytecompiler/mod.rs

@@ -48,7 +48,7 @@ pub(crate) enum NodeKind {
 
 /// Describes the type of a function.
 #[derive(Debug, Clone, Copy, PartialEq)]
-enum FunctionKind {
+pub(crate) enum FunctionKind {
     Ordinary,
     Arrow,
     AsyncArrow,
@@ -57,37 +57,31 @@ enum FunctionKind {
     AsyncGenerator,
 }
 
+impl FunctionKind {
+    pub(crate) const fn is_arrow(self) -> bool {
+        matches!(self, Self::Arrow | Self::AsyncArrow)
+    }
+
+    pub(crate) const fn is_async(self) -> bool {
+        matches!(self, Self::Async | Self::AsyncGenerator | Self::AsyncArrow)
+    }
+
+    pub(crate) const fn is_generator(self) -> bool {
+        matches!(self, Self::Generator | Self::AsyncGenerator)
+    }
+}
+
 /// Describes the complete specification of a function node.
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[allow(single_use_lifetimes)]
 pub(crate) struct FunctionSpec<'a> {
-    kind: FunctionKind,
+    pub(crate) kind: FunctionKind,
     pub(crate) name: Option<Identifier>,
     parameters: &'a FormalParameterList,
     body: &'a FunctionBody,
     has_binding_identifier: bool,
 }
 
-impl FunctionSpec<'_> {
-    const fn is_arrow(&self) -> bool {
-        matches!(self.kind, FunctionKind::Arrow | FunctionKind::AsyncArrow)
-    }
-
-    const fn is_async(&self) -> bool {
-        matches!(
-            self.kind,
-            FunctionKind::Async | FunctionKind::AsyncGenerator | FunctionKind::AsyncArrow
-        )
-    }
-
-    const fn is_generator(&self) -> bool {
-        matches!(
-            self.kind,
-            FunctionKind::Generator | FunctionKind::AsyncGenerator
-        )
-    }
-}
-
 impl<'a> From<&'a Function> for FunctionSpec<'a> {
     fn from(function: &'a Function) -> Self {
         FunctionSpec {
@@ -1070,17 +1064,13 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
         }
     }
 
-    /// Compile a function AST Node into bytecode.
-    pub(crate) fn function(
-        &mut self,
-        function: FunctionSpec<'_>,
-        node_kind: NodeKind,
-        use_expr: bool,
-    ) {
+    /// Compiles a function AST Node into bytecode, and returns its index into
+    /// the `functions` array.
+    pub(crate) fn function(&mut self, function: FunctionSpec<'_>) -> u32 {
         let (generator, r#async, arrow) = (
-            function.is_generator(),
-            function.is_async(),
-            function.is_arrow(),
+            function.kind.is_generator(),
+            function.kind.is_async(),
+            function.kind.is_arrow(),
         );
         let FunctionSpec {
             name,
@@ -1117,6 +1107,26 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
         let index = self.functions.len() as u32;
         self.functions.push(code);
 
+        index
+    }
+
+    /// Compiles a function AST Node into bytecode, setting its corresponding binding or
+    /// pushing it to the stack if necessary.
+    pub(crate) fn function_with_binding(
+        &mut self,
+        function: FunctionSpec<'_>,
+        node_kind: NodeKind,
+        use_expr: bool,
+    ) {
+        let name = function.name;
+        let (generator, r#async, arrow) = (
+            function.kind.is_generator(),
+            function.kind.is_async(),
+            function.kind.is_arrow(),
+        );
+
+        let index = self.function(function);
+
         if r#async && generator {
             self.emit(Opcode::GetGeneratorAsync, &[index]);
         } else if generator {
@@ -1152,9 +1162,9 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
     /// Compile an object method AST Node into bytecode.
     pub(crate) fn object_method(&mut self, function: FunctionSpec<'_>) {
         let (generator, r#async, arrow) = (
-            function.is_generator(),
-            function.is_async(),
-            function.is_arrow(),
+            function.kind.is_generator(),
+            function.kind.is_async(),
+            function.kind.is_arrow(),
         );
         let FunctionSpec {
             name,
@@ -1212,9 +1222,9 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
     /// Compile a class method AST Node into bytecode.
     fn method(&mut self, function: FunctionSpec<'_>, class_name: Sym) {
         let (generator, r#async, arrow) = (
-            function.is_generator(),
-            function.is_async(),
-            function.is_arrow(),
+            function.kind.is_generator(),
+            function.kind.is_async(),
+            function.kind.is_arrow(),
         );
         let FunctionSpec {
             name,

boa_engine/src/bytecompiler/module.rs

@@ -1,6 +1,6 @@
-use crate::vm::BindingOpcode;
+use crate::vm::{BindingOpcode, Opcode};
 
-use super::ByteCompiler;
+use super::{ByteCompiler, Literal};
 use boa_ast::{declaration::ExportDeclaration, expression::Identifier, ModuleItem, ModuleItemList};
 use boa_interner::Sym;
 
@@ -55,6 +55,18 @@ impl ByteCompiler<'_, '_> {
                         let name = Identifier::from(Sym::DEFAULT_EXPORT);
                         self.create_mutable_binding(name, false);
                         self.compile_expr(expr, true);
+
+                        if expr.is_anonymous_function_definition() {
+                            let default = self
+                                .interner()
+                                .resolve_expect(Sym::DEFAULT)
+                                .into_common(false);
+                            self.emit_push_literal(Literal::String(default));
+                            self.emit_opcode(Opcode::Swap);
+                            self.emit_opcode(Opcode::SetFunctionName);
+                            self.emit_u8(0);
+                        }
+
                         self.emit_binding(BindingOpcode::InitLet, name);
                     }
                 }

boa_engine/src/bytecompiler/statement/labelled.rs

@@ -34,7 +34,7 @@ impl ByteCompiler<'_, '_> {
                 stmt => self.compile_stmt(stmt, use_expr),
             },
             LabelledItem::Function(f) => {
-                self.function(f.into(), NodeKind::Declaration, false);
+                self.function_with_binding(f.into(), NodeKind::Declaration, false);
             }
         }
 

boa_engine/src/module/source.rs

@@ -1,4 +1,9 @@
-use std::{cell::Cell, collections::HashSet, hash::Hash, rc::Rc};
+use std::{
+    cell::Cell,
+    collections::HashSet,
+    hash::{BuildHasherDefault, Hash},
+    rc::Rc,
+};
 
 use boa_ast::{
     declaration::{
@@ -12,16 +17,20 @@ use boa_ast::{
 };
 use boa_gc::{custom_trace, empty_trace, Finalize, Gc, GcRefCell, Trace};
 use boa_interner::Sym;
-use rustc_hash::{FxHashMap, FxHashSet};
+use indexmap::IndexSet;
+use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 
 use crate::{
     builtins::{promise::PromiseCapability, Promise},
-    bytecompiler::{ByteCompiler, NodeKind},
+    bytecompiler::{ByteCompiler, FunctionSpec},
     environments::{BindingLocator, CompileTimeEnvironment, EnvironmentStack},
     module::ModuleKind,
     object::{FunctionObjectBuilder, JsPromise, RecursionLimiter},
     realm::Realm,
-    vm::{ActiveRunnable, CallFrame, CodeBlock, CompletionRecord, Opcode},
+    vm::{
+        create_function_object_fast, create_generator_function_object, ActiveRunnable, CallFrame,
+        CodeBlock, CompletionRecord, Opcode,
+    },
     Context, JsArgs, JsError, JsNativeError, JsObject, JsResult, JsString, JsValue, NativeFunction,
 };
 
@@ -273,7 +282,7 @@ struct Inner {
 #[derive(Debug)]
 struct ModuleCode {
     has_tla: bool,
-    requested_modules: FxHashSet<Sym>,
+    requested_modules: IndexSet<Sym, BuildHasherDefault<FxHasher>>,
     source: boa_ast::Module,
     import_entries: Vec<ImportEntry>,
     local_export_entries: Vec<LocalExportEntry>,
@@ -1403,7 +1412,7 @@ impl SourceTextModule {
             ByteCompiler::new(Sym::MAIN, true, false, module_compile_env.clone(), context);
         let mut imports = Vec::new();
 
-        let codeblock = {
+        let (codeblock, functions) = {
             // 7. For each ImportEntry Record in of module.[[ImportEntries]], do
             for entry in &self.inner.code.import_entries {
                 // a. Let importedModule be GetImportedModule(module, in.[[ModuleRequest]]).
@@ -1448,7 +1457,7 @@ impl SourceTextModule {
                         // deferred to initialization below
                         imports.push(ImportBinding::Namespace {
                             locator,
-                            module: imported_module,
+                            module: resolution.module,
                         });
                     }
                 } else {
@@ -1494,47 +1503,87 @@ impl SourceTextModule {
             // 22. Let lexDeclarations be the LexicallyScopedDeclarations of code.
             // 23. Let privateEnv be null.
             let lex_declarations = lexically_scoped_declarations(&self.inner.code.source);
+            let mut functions = Vec::new();
             // 24. For each element d of lexDeclarations, do
             for declaration in &lex_declarations {
+                // ii. Else,
+                // a. For each element dn of the BoundNames of d, do
+                // 1. Perform ! env.CreateMutableBinding(dn, false).
+                //
+                // iii. If d is either a FunctionDeclaration, a GeneratorDeclaration, an
+                //      AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
+                // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
+                // 2. Perform ! env.InitializeBinding(dn, fo).
+                //
+                // deferred to below.
+                let (spec, locator): (FunctionSpec<'_>, _) = match declaration {
+                    LexicallyScopedDeclaration::Function(f) => {
+                        let name = bound_names(f)[0];
+                        compiler.create_mutable_binding(name, false);
+                        let locator = compiler.initialize_mutable_binding(name, false);
+
+                        (f.into(), locator)
+                    }
+                    LexicallyScopedDeclaration::Generator(g) => {
+                        let name = bound_names(g)[0];
+                        compiler.create_mutable_binding(name, false);
+                        let locator = compiler.initialize_mutable_binding(name, false);
+
+                        (g.into(), locator)
+                    }
+                    LexicallyScopedDeclaration::AsyncFunction(af) => {
+                        let name = bound_names(af)[0];
+                        compiler.create_mutable_binding(name, false);
+                        let locator = compiler.initialize_mutable_binding(name, false);
+
+                        (af.into(), locator)
+                    }
+                    LexicallyScopedDeclaration::AsyncGenerator(ag) => {
+                        let name = bound_names(ag)[0];
+                        compiler.create_mutable_binding(name, false);
+                        let locator = compiler.initialize_mutable_binding(name, false);
+
+                        (ag.into(), locator)
+                    }
+                    LexicallyScopedDeclaration::Class(class) => {
+                        for name in bound_names(class) {
+                            compiler.create_mutable_binding(name, false);
+                        }
+                        continue;
+                    }
                     // i. If IsConstantDeclaration of d is true, then
-                if let LexicallyScopedDeclaration::LexicalDeclaration(LexicalDeclaration::Const(
-                    decl,
-                )) = declaration
-                {
+                    LexicallyScopedDeclaration::LexicalDeclaration(LexicalDeclaration::Const(
+                        c,
+                    )) => {
                         // a. For each element dn of the BoundNames of d, do
-                    for name in bound_names(decl) {
+                        for name in bound_names(c) {
                             // 1. Perform ! env.CreateImmutableBinding(dn, true).
                             compiler.create_immutable_binding(name, true);
                         }
-                } else {
-                    // ii. Else,
-                    // a. For each element dn of the BoundNames of d, do
-                    for name in declaration.bound_names() {
-                        // 1. Perform ! env.CreateMutableBinding(dn, false).
+                        continue;
+                    }
+                    LexicallyScopedDeclaration::LexicalDeclaration(LexicalDeclaration::Let(l)) => {
+                        for name in bound_names(l) {
                             compiler.create_mutable_binding(name, false);
                         }
+                        continue;
+                    }
+                    LexicallyScopedDeclaration::AssignmentExpression(expr) => {
+                        for name in bound_names(expr) {
+                            compiler.create_mutable_binding(name, false);
+                        }
+                        continue;
                     }
-
-                // iii. If d is either a FunctionDeclaration, a GeneratorDeclaration, an
-                //      AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
-                // 1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
-                // 2. Perform ! env.InitializeBinding(dn, fo).
-                let spec = match declaration {
-                    LexicallyScopedDeclaration::Function(f) => f.into(),
-                    LexicallyScopedDeclaration::Generator(g) => g.into(),
-                    LexicallyScopedDeclaration::AsyncFunction(af) => af.into(),
-                    LexicallyScopedDeclaration::AsyncGenerator(ag) => ag.into(),
-                    LexicallyScopedDeclaration::Class(_)
-                    | LexicallyScopedDeclaration::LexicalDeclaration(_)
-                    | LexicallyScopedDeclaration::AssignmentExpression(_) => continue,
                 };
 
-                compiler.function(spec, NodeKind::Declaration, false);
+                let kind = spec.kind;
+
+                functions.push((compiler.function(spec), locator, kind));
             }
 
             compiler.compile_module_item_list(self.inner.code.source.items());
 
-            Gc::new(compiler.finish())
+            (Gc::new(compiler.finish()), functions)
         };
 
         // 8. Let moduleContext be a new ECMAScript code execution context.
@@ -1598,6 +1647,23 @@ impl SourceTextModule {
             }
         }
 
+        // deferred initialization of function exports
+        for (index, locator, kind) in functions {
+            let code = codeblock.functions[index as usize].clone();
+
+            let function = if kind.is_generator() {
+                create_generator_function_object(code, kind.is_async(), None, context)
+            } else {
+                create_function_object_fast(code, kind.is_async(), false, false, context)
+            };
+
+            context.vm.environments.put_lexical_value(
+                locator.environment_index(),
+                locator.binding_index(),
+                function.into(),
+            );
+        }
+
         // 25. Remove moduleContext from the execution context stack.
         std::mem::swap(&mut context.vm.environments, &mut envs);
         context.vm.stack = stack;

boa_engine/src/object/internal_methods/module_namespace.rs

@@ -1,6 +1,7 @@
 use std::collections::HashSet;
 
 use crate::{
+    js_string,
     module::BindingName,
     object::{JsObject, JsPrototype},
     property::{PropertyDescriptor, PropertyKey},
@@ -88,8 +89,8 @@ fn module_namespace_exotic_get_own_property(
     // 1. If P is a Symbol, return OrdinaryGetOwnProperty(O, P).
     let key = match key {
         PropertyKey::Symbol(_) => return ordinary_get_own_property(obj, key, context),
-        PropertyKey::Index(_) => return Ok(None),
-        PropertyKey::String(s) => s,
+        PropertyKey::Index(idx) => js_string!(format!("{idx}")),
+        PropertyKey::String(s) => s.clone(),
     };
 
     {
@@ -101,13 +102,13 @@ fn module_namespace_exotic_get_own_property(
         let exports = obj.exports();
 
         // 3. If exports does not contain P, return undefined.
-        if !exports.contains_key(key) {
+        if !exports.contains_key(&key) {
             return Ok(None);
         }
     }
 
     // 4. Let value be ? O.[[Get]](P, O).
-    let value = obj.get(key.clone(), context)?;
+    let value = obj.get(key, context)?;
 
     // 5. Return PropertyDescriptor { [[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false }.
     Ok(Some(
@@ -168,8 +169,8 @@ fn module_namespace_exotic_has_property(
     // 1. If P is a Symbol, return ! OrdinaryHasProperty(O, P).
     let key = match key {
         PropertyKey::Symbol(_) => return ordinary_has_property(obj, key, context),
-        PropertyKey::Index(_) => return Ok(false),
-        PropertyKey::String(s) => s,
+        PropertyKey::Index(idx) => js_string!(format!("{idx}")),
+        PropertyKey::String(s) => s.clone(),
     };
 
     let obj = obj.borrow();
@@ -182,7 +183,7 @@ fn module_namespace_exotic_has_property(
 
     // 3. If exports contains P, return true.
     // 4. Return false.
-    Ok(exports.contains_key(key))
+    Ok(exports.contains_key(&key))
 }
 
 /// [`[[Get]] ( P, Receiver )`][spec]
@@ -198,8 +199,8 @@ fn module_namespace_exotic_get(
     //     a. Return ! OrdinaryGet(O, P, Receiver).
     let key = match key {
         PropertyKey::Symbol(_) => return ordinary_get(obj, key, receiver, context),
-        PropertyKey::Index(_) => return Ok(JsValue::undefined()),
-        PropertyKey::String(s) => s,
+        PropertyKey::Index(idx) => js_string!(format!("{idx}")),
+        PropertyKey::String(s) => s.clone(),
     };
 
     let obj = obj.borrow();
@@ -210,7 +211,7 @@ fn module_namespace_exotic_get(
     // 2. Let exports be O.[[Exports]].
     let exports = obj.exports();
     // 3. If exports does not contain P, return undefined.
-    let Some(export_name) = exports.get(key).copied() else {
+    let Some(export_name) = exports.get(&key).copied() else {
         return Ok(JsValue::undefined());
     };
 
@@ -285,8 +286,8 @@ fn module_namespace_exotic_delete(
     //     a. Return ! OrdinaryDelete(O, P).
     let key = match key {
         PropertyKey::Symbol(_) => return ordinary_delete(obj, key, context),
-        PropertyKey::Index(_) => return Ok(true),
-        PropertyKey::String(s) => s,
+        PropertyKey::Index(idx) => js_string!(format!("{idx}")),
+        PropertyKey::String(s) => s.clone(),
     };
 
     let obj = obj.borrow();
@@ -299,7 +300,7 @@ fn module_namespace_exotic_delete(
 
     // 3. If exports contains P, return false.
     // 4. Return true.
-    Ok(!exports.contains_key(key))
+    Ok(!exports.contains_key(&key))
 }
 
 /// [`[[OwnPropertyKeys]] ( )`][spec].

boa_engine/src/tests/mod.rs

@@ -422,8 +422,8 @@ fn strict_mode_reserved_name() {
         ("var protected = 10;", "unexpected token 'protected', strict reserved word cannot be an identifier at line 1, col 19"),
         ("var public = 10;", "unexpected token 'public', strict reserved word cannot be an identifier at line 1, col 19"),
         ("var static = 10;", "unexpected token 'static', strict reserved word cannot be an identifier at line 1, col 19"),
-        ("var eval = 10;", "unexpected token 'eval', binding identifier `eval` not allowed in strict mode at line 1, col 19"),
-        ("var arguments = 10;", "unexpected token 'arguments', binding identifier `arguments` not allowed in strict mode at line 1, col 19"),
+        ("var eval = 10;", "binding identifier `eval` not allowed in strict mode at line 1, col 19"),
+        ("var arguments = 10;", "binding identifier `arguments` not allowed in strict mode at line 1, col 19"),
         ("var let = 10;", "unexpected token 'let', strict reserved word cannot be an identifier at line 1, col 19"),
         ("var yield = 10;", "unexpected token 'yield', strict reserved word cannot be an identifier at line 1, col 19"),
     ];

boa_parser/src/parser/expression/identifiers.rs

@@ -114,21 +114,18 @@ where
                     .resolve_expect(ident.sym())
                     .utf8()
                     .expect("keyword must be utf-8");
-                Err(Error::unexpected(
-                    name,
-                    span,
+                Err(Error::general(
                     format!("binding identifier `{name}` not allowed in strict mode"),
+                    span.start(),
                 ))
             }
-            Sym::YIELD if self.allow_yield.0 => Err(Error::unexpected(
-                "yield",
-                span,
+            Sym::YIELD if self.allow_yield.0 => Err(Error::general(
                 "keyword `yield` not allowed in this context",
+                span.start(),
             )),
-            Sym::AWAIT if self.allow_await.0 => Err(Error::unexpected(
-                "await",
-                span,
+            Sym::AWAIT if self.allow_await.0 => Err(Error::general(
                 "keyword `await` not allowed in this context",
+                span.start(),
             )),
             _ => Ok(ident),
         }

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

@@ -52,6 +52,7 @@ where
         cursor.expect((Keyword::Export, false), "export declaration", interner)?;
 
         let tok = cursor.peek(0, interner).or_abrupt()?;
+        let span = tok.span();
 
         let export_clause: Self::Output = match tok.kind() {
             TokenKind::Punctuator(Punctuator::Mul) => {
@@ -130,6 +131,33 @@ where
                 } else {
                     cursor.expect_semicolon("named exports", interner)?;
 
+                    for specifier in &*names {
+                        let name = specifier.private_name();
+
+                        if specifier.string_literal() {
+                            let name = interner.resolve_expect(name);
+                            return Err(Error::general(
+                                format!(
+                                    "local referenced binding `{name}` cannot be a string literal",
+                                ),
+                                span.start(),
+                            ));
+                        }
+
+                        if name == Sym::AWAIT
+                            || name.is_reserved_identifier()
+                            || name.is_strict_reserved_identifier()
+                        {
+                            let name = interner.resolve_expect(name);
+                            return Err(Error::general(
+                                format!(
+                                    "local referenced binding `{name}` cannot be a reserved word",
+                                ),
+                                span.start(),
+                            ));
+                        }
+                    }
+
                     AstExportDeclaration::List(names)
                 }
             }
@@ -272,7 +300,7 @@ impl<R> TokenParser<R> for ModuleExportName
 where
     R: Read,
 {
-    type Output = Sym;
+    type Output = (Sym, bool);
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
         let tok = cursor.next(interner).or_abrupt()?;
@@ -285,10 +313,10 @@ where
                         tok.span().end(),
                     ));
                 }
-                Ok(*ident)
+                Ok((*ident, true))
             }
-            TokenKind::IdentifierName((ident, _)) => Ok(*ident),
-            TokenKind::Keyword((kw, _)) => Ok(kw.to_sym()),
+            TokenKind::IdentifierName((ident, _)) => Ok((*ident, false)),
+            TokenKind::Keyword((kw, _)) => Ok((kw.to_sym(), false)),
             _ => Err(Error::expected(
                 ["identifier".to_owned(), "string literal".to_owned()],
                 tok.to_string(interner),
@@ -315,20 +343,23 @@ where
     type Output = boa_ast::declaration::ExportSpecifier;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
-        let inner_name = ModuleExportName.parse(cursor, interner)?;
+        let (inner_name, string_literal) = ModuleExportName.parse(cursor, interner)?;
 
         if cursor
             .next_if(TokenKind::identifier(Sym::AS), interner)?
             .is_some()
         {
-            let export_name = ModuleExportName.parse(cursor, interner)?;
+            let (export_name, _) = ModuleExportName.parse(cursor, interner)?;
             Ok(boa_ast::declaration::ExportSpecifier::new(
                 export_name,
                 inner_name,
+                string_literal,
             ))
         } else {
             Ok(boa_ast::declaration::ExportSpecifier::new(
-                inner_name, inner_name,
+                inner_name,
+                inner_name,
+                string_literal,
             ))
         }
     }

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

@@ -58,9 +58,7 @@ impl ImportDeclaration {
                         TokenKind::StringLiteral(_)
                         | TokenKind::Punctuator(Punctuator::OpenBlock | Punctuator::Mul)
                         | TokenKind::IdentifierName(_)
-                        | TokenKind::Keyword((Keyword::Await | Keyword::Yield, _)) => {
-                            return Ok(true)
-                        }
+                        | TokenKind::Keyword(_) => return Ok(true),
                         _ => {}
                     }
                 }
@@ -225,7 +223,9 @@ where
                     }
                     cursor.advance(interner);
                 }
-                TokenKind::StringLiteral(_) | TokenKind::IdentifierName(_) => {
+                TokenKind::StringLiteral(_)
+                | TokenKind::IdentifierName(_)
+                | TokenKind::Keyword(_) => {
                     list.push(ImportSpecifier.parse(cursor, interner)?);
                 }
                 _ => {
@@ -293,16 +293,35 @@ where
     type Output = AstImportSpecifier;
 
     fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult<Self::Output> {
-        let tok = cursor.next(interner).or_abrupt()?;
+        let tok = cursor.peek(0, interner).or_abrupt()?;
 
         match tok.kind() {
             TokenKind::StringLiteral((name, _)) => {
-                if interner.resolve_expect(*name).utf8().is_none() {
+                let name = *name;
+                if interner.resolve_expect(name).utf8().is_none() {
                     return Err(Error::general(
                         "import specifiers don't allow unpaired surrogates",
                         tok.span().end(),
                     ));
                 }
+
+                cursor.advance(interner);
+
+                cursor.expect(
+                    TokenKind::identifier(Sym::AS),
+                    "import declaration",
+                    interner,
+                )?;
+
+                let binding = ImportedBinding.parse(cursor, interner)?;
+
+                Ok(AstImportSpecifier::new(binding, name))
+            }
+            TokenKind::Keyword((kw, _)) => {
+                let export_name = kw.to_sym();
+
+                cursor.advance(interner);
+
                 cursor.expect(
                     TokenKind::identifier(Sym::AS),
                     "import declaration",
@@ -311,19 +330,28 @@ where
 
                 let binding = ImportedBinding.parse(cursor, interner)?;
 
-                Ok(AstImportSpecifier::new(binding, *name))
+                Ok(AstImportSpecifier::new(binding, export_name))
             }
             TokenKind::IdentifierName((name, _)) => {
-                if cursor
-                    .next_if(TokenKind::identifier(Sym::AS), interner)?
-                    .is_some()
-                {
+                let name = *name;
+
+                if let Some(token) = cursor.peek(1, interner)? {
+                    if token.kind() == &TokenKind::identifier(Sym::AS) {
+                        // export name
+                        cursor.advance(interner);
+
+                        // `as`
+                        cursor.advance(interner);
+
                         let binding = ImportedBinding.parse(cursor, interner)?;
-                    Ok(AstImportSpecifier::new(binding, *name))
-                } else {
-                    Ok(AstImportSpecifier::new(Identifier::new(*name), *name))
+                        return Ok(AstImportSpecifier::new(binding, name));
                     }
                 }
+
+                let name = ImportedBinding.parse(cursor, interner)?;
+
+                Ok(AstImportSpecifier::new(name, name.sym()))
+            }
             _ => Err(Error::expected(
                 ["string literal".to_owned(), "identifier".to_owned()],
                 tok.to_string(interner),

test_ignore.toml

@@ -30,6 +30,8 @@ features = [
     "Intl-enumeration",
     # https://github.com/tc39/proposal-array-from-async
     "Array.fromAsync",
+    # https://github.com/tc39/proposal-import-attributes
+    "import-assertions",
 
     # Non-standard
     "caller",