Merge branch 'main' into feat/res2

Author: abhinavs1920

PR_MESSAGE_EXPECT_EXPRESSION.md

@@ -0,0 +1,30 @@
+# fix(parser): replace expect_expression panic with try_into_expression error handling
+
+## Summary
+
+Replaces all uses of `expect_expression()` with `try_into_expression()` in the parser, and removes the panicking `expect_expression()` method. When the parser encounters arrow-function parameter list syntax in a context that requires an expression (e.g. conditional operator `a ? b : c`, call expression `foo()`, optional chaining `a?.b`), it now returns a recoverable parse error instead of panicking.
+
+## Motivation
+
+The `FormalParameterListOrExpression` type represents the grammar ambiguity between `(a, b)` as a comma expression vs `(a, b)` as arrow-function parameters. In contexts like the conditional operator (`x ? y : z`), call expressions (`f()`), and optional chaining (`a?.b`), the left-hand side must be an expression—arrow params are invalid. Previously, call sites used `expect_expression()`, which panics with "Unexpected arrow-function arguments" when the parser produced a `FormalParameterList` instead of an `Expression`. This can occur with edge-case input such as `(a) ? 1 : 2` when `(a)` is parsed as a single arrow param. For Boa as an embedded engine or in tooling, panics are unacceptable; the host expects a parse error. The `try_into_expression()` method already existed and returns `Err(Error::General { ... })` with a helpful message ("invalid arrow-function arguments (parentheses around the arrow-function may help)"). Replacing `expect_expression()` with `try_into_expression()?` propagates that error instead of panicking, aligning with Boa's stability goals.
+
+## Changes
+
+| Category     | Description                                                                                           |
+| ------------ | ----------------------------------------------------------------------------------------------------- |
+| **Replaced** | `lhs.expect_expression()` with `lhs.try_into_expression()?` in conditional expression parser          |
+| **Replaced** | `member.expect_expression()` with `member.try_into_expression()?` in left-hand side (call expression) |
+| **Replaced** | `lhs.expect_expression()` with `lhs.try_into_expression()?` in left-hand side (optional expression)   |
+| **Removed**  | `expect_expression()` method from `FormalParameterListOrExpression` to prevent future misuse          |
+
+## Technical Details
+
+- **Files modified:** `core/parser/src/parser/expression/assignment/conditional.rs`, `core/parser/src/parser/expression/left_hand_side/mod.rs`, `core/parser/src/parser/expression/fpl_or_exp.rs`
+- **Lines changed:** ~15 lines across 3 files
+- **Behavioral impact:** Invalid input that previously caused a panic now produces `Err(Error::General { message: "invalid arrow-function arguments (parentheses around the arrow-function may help)", position })`. Valid input is unchanged.
+
+## Testing
+
+- [x] `cargo test -p boa_parser` — all 296 tests pass
+- [x] `cargo test -p boa_engine --lib` — all 921 tests pass
+- [x] `cargo clippy` — no warnings

benches/scripts/intl/datetimeformat_resolved_options.js

@@ -0,0 +1,12 @@
+const kIterationCount = 1000;
+const fmt = new Intl.DateTimeFormat("en-US", {
+  dateStyle: "full",
+  timeStyle: "short",
+  timeZone: "UTC",
+});
+
+function main() {
+  for (let i = 0; i < kIterationCount; i++) {
+    fmt.resolvedOptions();
+  }
+}

core/engine/src/builtins/bigint/mod.rs

@@ -13,7 +13,7 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt
 
 use crate::{
-    Context, JsArgs, JsBigInt, JsResult, JsString, JsValue,
+    Context, JsArgs, JsBigInt, JsExpect, JsResult, JsString, JsValue,
     builtins::BuiltInObject,
     context::intrinsics::{Intrinsics, StandardConstructor, StandardConstructors},
     error::JsNativeError,
@@ -122,7 +122,12 @@ impl BigInt {
         }
 
         // 2. Return the BigInt value that represents ℝ(number).
-        Ok(JsBigInt::from(number.to_bigint().expect("This conversion must be safe")).into())
+        Ok(JsBigInt::from(
+            number
+                .to_bigint()
+                .js_expect("This conversion must be safe")?,
+        )
+        .into())
     }
 
     /// The abstract operation `thisBigIntValue` takes argument value.

core/engine/src/builtins/error/aggregate.rs

@@ -8,7 +8,7 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError
 
 use crate::{
-    Context, JsArgs, JsResult, JsString, JsValue,
+    Context, JsArgs, JsExpect, JsResult, JsString, JsValue,
     builtins::{
         Array, BuiltInBuilder, BuiltInConstructor, BuiltInObject, IntrinsicObject,
         iterable::IteratorHint,
@@ -128,7 +128,7 @@ impl BuiltInConstructor for AggregateError {
                 .build(),
             context,
         )
-        .expect("should not fail according to spec");
+        .js_expect("should not fail according to spec")?;
 
         // 5. Return O.
         Ok(o.into())

core/engine/src/builtins/eval/mod.rs

@@ -10,7 +10,7 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
 use crate::{
-    Context, JsArgs, JsResult, JsString, JsValue, SpannedSourceText,
+    Context, JsArgs, JsExpect, JsResult, JsString, JsValue, SpannedSourceText,
     builtins::{BuiltInObject, function::OrdinaryFunction},
     bytecompiler::{ByteCompiler, prepare_eval_declaration_instantiation},
     context::intrinsics::Intrinsics,
@@ -152,7 +152,7 @@ impl Eval {
                     .slots()
                     .function_object()
                     .downcast_ref::<OrdinaryFunction>()
-                    .expect("must be function object");
+                    .js_expect("must be function object")?;
 
                 // ii. Set inFunction to true.
                 let mut flags = Flags::IN_FUNCTION;

core/engine/src/builtins/generator/mod.rs

@@ -10,10 +10,11 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator
 
 use crate::{
-    Context, JsArgs, JsData, JsError, JsResult, JsString,
+    Context, JsArgs, JsData, JsError, JsExpect, JsResult, JsString,
     builtins::iterable::create_iter_result_object,
     context::intrinsics::Intrinsics,
     error::JsNativeError,
+    error::PanicError,
     js_string,
     object::{CONSTRUCTOR, JsObject},
     property::Attribute,
@@ -101,7 +102,9 @@ impl GeneratorContext {
         context: &mut Context,
     ) -> CompletionRecord {
         std::mem::swap(&mut context.vm.stack, &mut self.stack);
-        let frame = self.call_frame.take().expect("should have a call frame");
+        let Some(frame) = self.call_frame.take() else {
+            return CompletionRecord::Throw(PanicError::new("should have a call frame").into());
+        };
         let fp = frame.fp;
         let rp = frame.rp;
         context.vm.push_frame(frame);
@@ -125,16 +128,21 @@ impl GeneratorContext {
     }
 
     /// Returns the async generator object, if the function that this [`GeneratorContext`] is from an async generator, [`None`] otherwise.
-    pub(crate) fn async_generator_object(&self) -> Option<JsObject> {
-        let frame = self.call_frame.as_ref()?;
+    pub(crate) fn async_generator_object(&self) -> JsResult<Option<JsObject>> {
+        let Some(frame) = self.call_frame.as_ref() else {
+            return Ok(None);
+        };
+
         if !frame.code_block().is_async_generator() {
-            return None;
+            return Ok(None);
         }
 
-        self.stack
+        let val = self
+            .stack
             .get_register(frame, CallFrame::ASYNC_GENERATOR_OBJECT_REGISTER_INDEX)
-            .expect("registers must have an async generator object")
-            .as_object()
+            .js_expect("registers must have an async generator object")?;
+
+        Ok(val.as_object())
     }
 }
 
@@ -306,7 +314,7 @@ impl Generator {
 
         let mut r#gen = generator_obj
             .downcast_mut::<Self>()
-            .expect("already checked this object type");
+            .js_expect("already checked this object type")?;
 
         // 8. Push genContext onto the execution context stack; genContext is now the running execution context.
         // 9. Resume the suspended evaluation of genContext using NormalCompletion(value) as the result of the operation that suspended it. Let result be the value returned by the resumed computation.