ctx

Author: kdy1

crates/swc_ecma_compiler/src/compat/es2015/arrow_functions.rs

@@ -161,11 +161,9 @@ pub struct ArrowFunctionsOptions {
 /// - `() => expr` becomes `function() { return expr; }`
 /// - `() => { stmt }` becomes `function() { stmt }`
 /// - Handles `this` binding by creating `var _this = this;` when needed
-pub struct ArrowFunctions<'ctx> {
+pub struct ArrowFunctions {
     #[allow(dead_code)]
     options: ArrowFunctionsOptions,
-    #[allow(dead_code)]
-    ctx: &'ctx TransformCtx,
 
     /// Tracks whether we need to create a `_this` variable
     needs_this_binding: bool,
@@ -183,17 +181,15 @@ pub struct ArrowFunctions<'ctx> {
     this_var_name: Option<Atom>,
 }
 
-impl<'ctx> ArrowFunctions<'ctx> {
+impl ArrowFunctions {
     /// Create a new arrow functions transformer.
     ///
     /// # Arguments
     ///
     /// * `options` - Configuration options for arrow function transformation
-    /// * `ctx` - Transform context containing shared state and utilities
-    pub fn new(options: ArrowFunctionsOptions, ctx: &'ctx TransformCtx) -> Self {
+    pub fn new(options: ArrowFunctionsOptions) -> Self {
         Self {
             options,
-            ctx,
             needs_this_binding: false,
             var_declarations: VarDeclarationsStore::new(),
             uid_counter: 0,
@@ -280,9 +276,9 @@ impl<'ctx> ArrowFunctions<'ctx> {
     }
 }
 
-impl VisitMutHook for ArrowFunctions<'_> {
+impl VisitMutHook<TransformCtx> for ArrowFunctions {
     /// Called when entering an expression node.
-    fn exit_expr(&mut self, expr: &mut Expr) {
+    fn exit_expr(&mut self, expr: &mut Expr, _ctx: &mut TransformCtx) {
         // Transform arrow functions to regular functions
         if let Expr::Arrow(arrow) = expr {
             let transformed = self.transform_arrow_function(arrow);
@@ -291,40 +287,40 @@ impl VisitMutHook for ArrowFunctions<'_> {
     }
 
     /// Called when entering a function - increment depth to track scope
-    fn enter_fn_decl(&mut self, _func: &mut FnDecl) {
+    fn enter_fn_decl(&mut self, _func: &mut FnDecl, _ctx: &mut TransformCtx) {
         self.function_depth += 1;
     }
 
     /// Called when exiting a function - decrement depth
-    fn exit_fn_decl(&mut self, _func: &mut FnDecl) {
+    fn exit_fn_decl(&mut self, _func: &mut FnDecl, _ctx: &mut TransformCtx) {
         self.function_depth -= 1;
     }
 
     /// Called when entering a function expression - increment depth
-    fn enter_fn_expr(&mut self, _func: &mut FnExpr) {
+    fn enter_fn_expr(&mut self, _func: &mut FnExpr, _ctx: &mut TransformCtx) {
         self.function_depth += 1;
     }
 
     /// Called when exiting a function expression - decrement depth
-    fn exit_fn_expr(&mut self, _func: &mut FnExpr) {
+    fn exit_fn_expr(&mut self, _func: &mut FnExpr, _ctx: &mut TransformCtx) {
         self.function_depth -= 1;
     }
 
     /// Called when encountering `this` expression
-    fn enter_this_expr(&mut self, this_expr: &mut ThisExpr) {
+    fn enter_this_expr(&mut self, this_expr: &mut ThisExpr, _ctx: &mut TransformCtx) {
         // If we're inside an arrow function (function_depth tracking would need more
         // work) Mark that we need a this binding
         // For now, we'll handle this in a simpler way
         let _ = this_expr;
     }
 
     /// Called when entering a module - record for variable declarations
-    fn enter_module(&mut self, _module: &mut Module) {
+    fn enter_module(&mut self, _module: &mut Module, _ctx: &mut TransformCtx) {
         self.var_declarations.record_entering_statements();
     }
 
     /// Called when exiting a module - insert variable declarations
-    fn exit_module(&mut self, module: &mut Module) {
+    fn exit_module(&mut self, module: &mut Module, _ctx: &mut TransformCtx) {
         // Insert variable declarations at the top of the module if needed
         if self.needs_this_binding {
             if let Some(this_var_name) = &self.this_var_name {
@@ -351,12 +347,12 @@ impl VisitMutHook for ArrowFunctions<'_> {
     }
 
     /// Called when entering a block statement
-    fn enter_block_stmt(&mut self, _block: &mut BlockStmt) {
+    fn enter_block_stmt(&mut self, _block: &mut BlockStmt, _ctx: &mut TransformCtx) {
         self.var_declarations.record_entering_statements();
     }
 
     /// Called when exiting a block statement
-    fn exit_block_stmt(&mut self, block: &mut BlockStmt) {
+    fn exit_block_stmt(&mut self, block: &mut BlockStmt, _ctx: &mut TransformCtx) {
         self.var_declarations
             .insert_into_statements(&mut block.stmts);
     }

crates/swc_ecma_compiler/src/compat/es2015/mod.rs

@@ -47,69 +47,68 @@ pub use options::ES2015Options;
 /// This struct orchestrates the various ES2015 transformations and applies
 /// them in the correct order. It follows SWC's VisitMutHook pattern rather than
 /// oxc's Traverse pattern.
-pub struct ES2015<'ctx> {
+pub struct ES2015 {
     #[allow(dead_code)]
     options: ES2015Options,
 
     // Plugins
-    arrow_functions: ArrowFunctions<'ctx>,
+    arrow_functions: ArrowFunctions,
 }
 
-impl<'ctx> ES2015<'ctx> {
+impl ES2015 {
     /// Create a new ES2015 transformer.
     ///
     /// # Arguments
     ///
     /// * `options` - Configuration for ES2015 transformations
-    /// * `ctx` - Transform context containing shared state and utilities
-    pub fn new(options: ES2015Options, ctx: &'ctx TransformCtx) -> Self {
+    pub fn new(options: ES2015Options) -> Self {
         Self {
-            arrow_functions: ArrowFunctions::new(options.arrow_function.unwrap_or_default(), ctx),
+            arrow_functions: ArrowFunctions::new(options.arrow_function.unwrap_or_default()),
             options,
         }
     }
 }
 
-impl VisitMutHook for ES2015<'_> {
+impl VisitMutHook<TransformCtx> for ES2015 {
     // Delegate to arrow functions transformer
 
-    fn exit_expr(&mut self, expr: &mut swc_ecma_ast::Expr) {
-        self.arrow_functions.exit_expr(expr);
+    fn exit_expr(&mut self, expr: &mut swc_ecma_ast::Expr, ctx: &mut TransformCtx) {
+        self.arrow_functions.exit_expr(expr, ctx);
     }
 
-    fn enter_fn_decl(&mut self, func: &mut swc_ecma_ast::FnDecl) {
-        self.arrow_functions.enter_fn_decl(func);
+    fn enter_fn_decl(&mut self, func: &mut swc_ecma_ast::FnDecl, ctx: &mut TransformCtx) {
+        self.arrow_functions.enter_fn_decl(func, ctx);
     }
 
-    fn exit_fn_decl(&mut self, func: &mut swc_ecma_ast::FnDecl) {
-        self.arrow_functions.exit_fn_decl(func);
+    fn exit_fn_decl(&mut self, func: &mut swc_ecma_ast::FnDecl, ctx: &mut TransformCtx) {
+        self.arrow_functions.exit_fn_decl(func, ctx);
     }
 
-    fn enter_fn_expr(&mut self, func: &mut swc_ecma_ast::FnExpr) {
-        self.arrow_functions.enter_fn_expr(func);
+    fn enter_fn_expr(&mut self, func: &mut swc_ecma_ast::FnExpr, ctx: &mut TransformCtx) {
+        self.arrow_functions.enter_fn_expr(func, ctx);
     }
 
-    fn exit_fn_expr(&mut self, func: &mut swc_ecma_ast::FnExpr) {
-        self.arrow_functions.exit_fn_expr(func);
+    fn exit_fn_expr(&mut self, func: &mut swc_ecma_ast::FnExpr, ctx: &mut TransformCtx) {
+        self.arrow_functions.exit_fn_expr(func, ctx);
     }
 
-    fn enter_this_expr(&mut self, this_expr: &mut swc_ecma_ast::ThisExpr) {
-        self.arrow_functions.enter_this_expr(this_expr);
+    fn enter_this_expr(&mut self, this_expr: &mut swc_ecma_ast::ThisExpr, ctx: &mut TransformCtx) {
+        self.arrow_functions.enter_this_expr(this_expr, ctx);
     }
 
-    fn enter_module(&mut self, module: &mut swc_ecma_ast::Module) {
-        self.arrow_functions.enter_module(module);
+    fn enter_module(&mut self, module: &mut swc_ecma_ast::Module, ctx: &mut TransformCtx) {
+        self.arrow_functions.enter_module(module, ctx);
     }
 
-    fn exit_module(&mut self, module: &mut swc_ecma_ast::Module) {
-        self.arrow_functions.exit_module(module);
+    fn exit_module(&mut self, module: &mut swc_ecma_ast::Module, ctx: &mut TransformCtx) {
+        self.arrow_functions.exit_module(module, ctx);
     }
 
-    fn enter_block_stmt(&mut self, block: &mut swc_ecma_ast::BlockStmt) {
-        self.arrow_functions.enter_block_stmt(block);
+    fn enter_block_stmt(&mut self, block: &mut swc_ecma_ast::BlockStmt, ctx: &mut TransformCtx) {
+        self.arrow_functions.enter_block_stmt(block, ctx);
     }
 
-    fn exit_block_stmt(&mut self, block: &mut swc_ecma_ast::BlockStmt) {
-        self.arrow_functions.exit_block_stmt(block);
+    fn exit_block_stmt(&mut self, block: &mut swc_ecma_ast::BlockStmt, ctx: &mut TransformCtx) {
+        self.arrow_functions.exit_block_stmt(block, ctx);
     }
 }

crates/swc_ecma_compiler/src/compat/es2016/exponentiation_operator.rs

@@ -41,26 +41,19 @@ use crate::compat::context::TransformCtx;
 /// Exponentiation operator transformer.
 ///
 /// Transforms `**` and `**=` operators to `Math.pow` calls.
-pub struct ExponentiationOperator<'ctx> {
-    #[allow(dead_code)]
-    ctx: &'ctx TransformCtx,
-}
+pub struct ExponentiationOperator;
 
-impl<'ctx> ExponentiationOperator<'ctx> {
+impl ExponentiationOperator {
     /// Create a new exponentiation operator transformer.
-    ///
-    /// # Arguments
-    ///
-    /// * `ctx` - Transform context containing shared state and utilities
-    pub fn new(ctx: &'ctx TransformCtx) -> Self {
-        Self { ctx }
+    pub fn new() -> Self {
+        Self
     }
 }
 
-impl VisitMutHook for ExponentiationOperator<'_> {
+impl VisitMutHook<TransformCtx> for ExponentiationOperator {
     // Note: Do not transform to `Math.pow` with BigInt arguments - that's a runtime
     // error
-    fn enter_expr(&mut self, expr: &mut Expr) {
+    fn enter_expr(&mut self, expr: &mut Expr, _ctx: &mut TransformCtx) {
         match expr {
             // `left ** right`
             Expr::Bin(bin_expr) if bin_expr.op == BinaryOp::Exp => {
@@ -121,7 +114,7 @@ impl VisitMutHook for ExponentiationOperator<'_> {
     }
 }
 
-impl ExponentiationOperator<'_> {
+impl ExponentiationOperator {
     /// Check if an expression is a BigInt literal.
     fn is_big_int_literal(&self, expr: &Expr) -> bool {
         matches!(expr, Expr::Lit(Lit::BigInt(_)))

crates/swc_ecma_compiler/src/compat/es2016/mod.rs

@@ -39,32 +39,31 @@ pub use options::ES2016Options;
 /// This struct orchestrates the various ES2016 transformations and applies
 /// them in the correct order. It follows SWC's VisitMutHook pattern rather than
 /// oxc's Traverse pattern.
-pub struct ES2016<'ctx> {
+pub struct ES2016 {
     options: ES2016Options,
 
     // Plugins
-    exponentiation_operator: ExponentiationOperator<'ctx>,
+    exponentiation_operator: ExponentiationOperator,
 }
 
-impl<'ctx> ES2016<'ctx> {
+impl ES2016 {
     /// Create a new ES2016 transformer.
     ///
     /// # Arguments
     ///
     /// * `options` - Configuration for ES2016 transformations
-    /// * `ctx` - Transform context containing shared state and utilities
-    pub fn new(options: ES2016Options, ctx: &'ctx TransformCtx) -> Self {
+    pub fn new(options: ES2016Options) -> Self {
         Self {
-            exponentiation_operator: ExponentiationOperator::new(ctx),
+            exponentiation_operator: ExponentiationOperator::new(),
             options,
         }
     }
 }
 
-impl VisitMutHook for ES2016<'_> {
-    fn enter_expr(&mut self, expr: &mut swc_ecma_ast::Expr) {
+impl VisitMutHook<TransformCtx> for ES2016 {
+    fn enter_expr(&mut self, expr: &mut swc_ecma_ast::Expr, ctx: &mut TransformCtx) {
         if self.options.exponentiation_operator {
-            self.exponentiation_operator.enter_expr(expr);
+            self.exponentiation_operator.enter_expr(expr, ctx);
         }
     }
 }