feat(transformer): transform object rest spread

crates/oxc_ast/src/ast_impl/js.rs

@@ -952,6 +952,16 @@ impl<'a> BindingPatternKind<'a> {
         matches!(self, Self::BindingIdentifier(_))
     }
 
+    #[allow(missing_docs)]
+    pub fn is_object_pattern(&self) -> bool {
+        matches!(self, Self::ObjectPattern(_))
+    }
+
+    #[allow(missing_docs)]
+    pub fn is_array_pattern(&self) -> bool {
+        matches!(self, Self::ArrayPattern(_))
+    }
+
     #[allow(missing_docs)]
     pub fn is_assignment_pattern(&self) -> bool {
         matches!(self, Self::AssignmentPattern(_))

crates/oxc_transformer/examples/transformer.rs

@@ -6,7 +6,7 @@ use oxc_codegen::CodeGenerator;
 use oxc_parser::Parser;
 use oxc_semantic::SemanticBuilder;
 use oxc_span::SourceType;
-use oxc_transformer::{EnvOptions, TransformOptions, Transformer};
+use oxc_transformer::{EnvOptions, HelperLoaderMode, TransformOptions, Transformer};
 use pico_args::Arguments;
 
 // Instruction:
@@ -55,7 +55,7 @@ fn main() {
 
     let (symbols, scopes) = ret.semantic.into_symbol_table_and_scope_tree();
 
-    let transform_options = if let Some(query) = &targets {
+    let mut transform_options = if let Some(query) = &targets {
         TransformOptions {
             env: EnvOptions::from_browserslist_query(query).unwrap(),
             ..TransformOptions::default()
@@ -66,6 +66,8 @@ fn main() {
         TransformOptions::enable_all()
     };
 
+    transform_options.helper_loader.mode = HelperLoaderMode::External;
+
     let ret = Transformer::new(&allocator, path, &transform_options).build_with_symbols_and_scopes(
         symbols,
         scopes,

crates/oxc_transformer/src/common/helper_loader.rs

@@ -143,6 +143,10 @@ pub enum Helper {
     AsyncToGenerator,
     ObjectSpread2,
     WrapAsyncGenerator,
+    Extends,
+    ObjectDestructuringEmpty,
+    ObjectWithoutProperties,
+    ToPropertyKey,
 }
 
 impl Helper {
@@ -154,6 +158,10 @@ impl Helper {
             Self::AsyncToGenerator => "asyncToGenerator",
             Self::ObjectSpread2 => "objectSpread2",
             Self::WrapAsyncGenerator => "wrapAsyncGenerator",
+            Self::Extends => "extends",
+            Self::ObjectDestructuringEmpty => "objectDestructuringEmpty",
+            Self::ObjectWithoutProperties => "objectWithoutProperties",
+            Self::ToPropertyKey => "toPropertyKey",
         }
     }
 }

crates/oxc_transformer/src/common/statement_injector.rs

@@ -79,7 +79,6 @@ impl<'a> StatementInjectorStore<'a> {
 // The non-trivial inner functions are not marked `#[inline]` - compiler can decide whether to inline or not.
 impl<'a> StatementInjectorStore<'a> {
     /// Add a statement to be inserted immediately before the target statement.
-    #[expect(dead_code)]
     #[inline]
     pub fn insert_before<A: GetAddress>(&self, target: &A, stmt: Statement<'a>) {
         self.insert_before_address(target.address(), stmt);

crates/oxc_transformer/src/compiler_assumptions.rs

@@ -25,7 +25,6 @@ pub struct CompilerAssumptions {
     pub enumerable_module_meta: bool,
 
     #[serde(default)]
-    #[deprecated = "Not Implemented"]
     pub ignore_function_length: bool,
 
     #[serde(default)]
@@ -60,7 +59,6 @@ pub struct CompilerAssumptions {
     pub no_uninitialized_private_field_access: bool,
 
     #[serde(default)]
-    #[deprecated = "Not Implemented"]
     pub object_rest_no_symbols: bool,
 
     #[serde(default)]

crates/oxc_transformer/src/es2018/mod.rs

@@ -2,10 +2,11 @@ pub(crate) mod async_generator_functions;
 mod object_rest_spread;
 mod options;
 
-use oxc_ast::ast::{Expression, ForOfStatement, Function, Statement};
+use oxc_ast::ast::*;
 use oxc_traverse::{Traverse, TraverseCtx};
 
 use crate::context::TransformCtx;
+
 use async_generator_functions::AsyncGeneratorFunctions;
 pub use object_rest_spread::{ObjectRestSpread, ObjectRestSpreadOptions};
 pub use options::ES2018Options;
@@ -32,6 +33,12 @@ impl<'a, 'ctx> ES2018<'a, 'ctx> {
 }
 
 impl<'a, 'ctx> Traverse<'a> for ES2018<'a, 'ctx> {
+    fn exit_program(&mut self, program: &mut oxc_ast::ast::Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.exit_program(program, ctx);
+        }
+    }
+
     fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         if self.options.object_rest_spread.is_some() {
             self.object_rest_spread.enter_expression(expr, ctx);
@@ -56,9 +63,34 @@ impl<'a, 'ctx> Traverse<'a> for ES2018<'a, 'ctx> {
         }
     }
 
-    fn enter_for_of_statement(&mut self, node: &mut ForOfStatement<'a>, ctx: &mut TraverseCtx<'a>) {
+    fn enter_for_in_statement(&mut self, stmt: &mut ForInStatement<'a>, ctx: &mut TraverseCtx<'a>) {
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.enter_for_in_statement(stmt, ctx);
+        }
+    }
+
+    fn enter_for_of_statement(&mut self, stmt: &mut ForOfStatement<'a>, ctx: &mut TraverseCtx<'a>) {
         if self.options.async_generator_functions {
-            self.async_generator_functions.enter_for_of_statement(node, ctx);
+            self.async_generator_functions.enter_for_of_statement(stmt, ctx);
+        }
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.enter_for_of_statement(stmt, ctx);
+        }
+    }
+
+    fn enter_arrow_function_expression(
+        &mut self,
+        arrow: &mut ArrowFunctionExpression<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.enter_arrow_function_expression(arrow, ctx);
+        }
+    }
+
+    fn enter_function(&mut self, func: &mut Function<'a>, ctx: &mut TraverseCtx<'a>) {
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.enter_function(func, ctx);
         }
     }
 
@@ -67,4 +99,20 @@ impl<'a, 'ctx> Traverse<'a> for ES2018<'a, 'ctx> {
             self.async_generator_functions.exit_function(node, ctx);
         }
     }
+
+    fn enter_variable_declaration(
+        &mut self,
+        decl: &mut VariableDeclaration<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.enter_variable_declaration(decl, ctx);
+        }
+    }
+
+    fn enter_catch_clause(&mut self, clause: &mut CatchClause<'a>, ctx: &mut TraverseCtx<'a>) {
+        if self.options.object_rest_spread.is_some() {
+            self.object_rest_spread.enter_catch_clause(clause, ctx);
+        }
+    }
 }