diff --git a/crates/oxc_transformer/src/es2015/arrow_functions.rs b/crates/oxc_transformer/src/es2015/arrow_functions.rs index d3f2d20a1e367..85de197df1302 100644 --- a/crates/oxc_transformer/src/es2015/arrow_functions.rs +++ b/crates/oxc_transformer/src/es2015/arrow_functions.rs @@ -131,10 +131,7 @@ use oxc_syntax::{ use oxc_traverse::{Ancestor, Traverse, TraverseCtx}; use serde::Deserialize; -use crate::{ - context::Ctx, - helpers::{bindings::BoundIdentifier, stack::SparseStack}, -}; +use crate::helpers::{bindings::BoundIdentifier, stack::SparseStack}; #[derive(Debug, Default, Clone, Deserialize)] pub struct ArrowFunctionsOptions { @@ -147,15 +144,14 @@ pub struct ArrowFunctionsOptions { } pub struct ArrowFunctions<'a> { - ctx: Ctx<'a>, _options: ArrowFunctionsOptions, this_var_stack: SparseStack>, } impl<'a> ArrowFunctions<'a> { - pub fn new(options: ArrowFunctionsOptions, ctx: Ctx<'a>) -> Self { + pub fn new(options: ArrowFunctionsOptions) -> Self { // `SparseStack` is created with 1 empty entry, for `Program` - Self { ctx, _options: options, this_var_stack: SparseStack::new() } + Self { _options: options, this_var_stack: SparseStack::new() } } } @@ -164,9 +160,13 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> { // /// Insert `var _this = this;` for the global scope. - fn exit_program(&mut self, program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) { + fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) { if let Some(this_var) = self.this_var_stack.take() { - self.insert_this_var_statement_at_the_top_of_statements(&mut program.body, &this_var); + self.insert_this_var_statement_at_the_top_of_statements( + &mut program.body, + &this_var, + ctx, + ); } debug_assert!(self.this_var_stack.len() == 1); } @@ -186,13 +186,14 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> { /// } /// ``` /// Insert the var _this = this; statement outside the arrow function - fn exit_function(&mut self, func: &mut Function<'a>, _ctx: &mut TraverseCtx<'a>) { + fn exit_function(&mut self, func: &mut Function<'a>, ctx: &mut TraverseCtx<'a>) { if let Some(this_var) = self.this_var_stack.pop() { let Some(body) = &mut func.body else { unreachable!() }; self.insert_this_var_statement_at_the_top_of_statements( &mut body.statements, &this_var, + ctx, ); } } @@ -201,9 +202,13 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> { self.this_var_stack.push(None); } - fn exit_static_block(&mut self, block: &mut StaticBlock<'a>, _ctx: &mut TraverseCtx<'a>) { + fn exit_static_block(&mut self, block: &mut StaticBlock<'a>, ctx: &mut TraverseCtx<'a>) { if let Some(this_var) = self.this_var_stack.pop() { - self.insert_this_var_statement_at_the_top_of_statements(&mut block.body, &this_var); + self.insert_this_var_statement_at_the_top_of_statements( + &mut block.body, + &this_var, + ctx, + ); } } @@ -214,7 +219,7 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> { ) { if let JSXElementName::ThisExpression(this) = element_name { if let Some(ident) = self.get_this_identifier(this.span, ctx) { - *element_name = self.ctx.ast.jsx_element_name_from_identifier_reference(ident); + *element_name = ctx.ast.jsx_element_name_from_identifier_reference(ident); } }; } @@ -226,8 +231,7 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> { ) { if let JSXMemberExpressionObject::ThisExpression(this) = object { if let Some(ident) = self.get_this_identifier(this.span, ctx) { - *object = - self.ctx.ast.jsx_member_expression_object_from_identifier_reference(ident); + *object = ctx.ast.jsx_member_expression_object_from_identifier_reference(ident); } } } @@ -235,7 +239,7 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> { fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { if let Expression::ThisExpression(this) = expr { if let Some(ident) = self.get_this_identifier(this.span, ctx) { - *expr = self.ctx.ast.expression_from_identifier_reference(ident); + *expr = ctx.ast.expression_from_identifier_reference(ident); } } } @@ -336,7 +340,7 @@ impl<'a> ArrowFunctions<'a> { // Function (includes class method body) | Ancestor::FunctionParams(_) | Ancestor::FunctionBody(_) - // Class property body + // Class property body | Ancestor::PropertyDefinitionValue(_) // Class static block | Ancestor::StaticBlockBody(_) => return None, @@ -352,6 +356,7 @@ impl<'a> ArrowFunctions<'a> { unreachable!(); } + #[expect(clippy::unused_self)] fn transform_arrow_function_expression( &mut self, arrow_function_expr: ArrowFunctionExpression<'a>, @@ -364,7 +369,7 @@ impl<'a> ArrowFunctions<'a> { let stmt = body.statements.pop().unwrap(); let Statement::ExpressionStatement(stmt) = stmt else { unreachable!() }; let stmt = stmt.unbox(); - let return_statement = self.ctx.ast.statement_return(stmt.span, Some(stmt.expression)); + let return_statement = ctx.ast.statement_return(stmt.span, Some(stmt.expression)); body.statements.push(return_statement); } @@ -387,35 +392,36 @@ impl<'a> ArrowFunctions<'a> { ); new_function.scope_id.set(Some(scope_id)); - Expression::FunctionExpression(self.ctx.ast.alloc(new_function)) + Expression::FunctionExpression(ctx.ast.alloc(new_function)) } /// Insert `var _this = this;` at the top of the statements. + #[expect(clippy::unused_self)] fn insert_this_var_statement_at_the_top_of_statements( &mut self, statements: &mut Vec<'a, Statement<'a>>, this_var: &BoundIdentifier<'a>, + ctx: &mut TraverseCtx<'a>, ) { - let binding_pattern = self.ctx.ast.binding_pattern( - self.ctx - .ast + let binding_pattern = ctx.ast.binding_pattern( + ctx.ast .binding_pattern_kind_from_binding_identifier(this_var.create_binding_identifier()), NONE, false, ); - let variable_declarator = self.ctx.ast.variable_declarator( + let variable_declarator = ctx.ast.variable_declarator( SPAN, VariableDeclarationKind::Var, binding_pattern, - Some(self.ctx.ast.expression_this(SPAN)), + Some(ctx.ast.expression_this(SPAN)), false, ); - let stmt = self.ctx.ast.alloc_variable_declaration( + let stmt = ctx.ast.alloc_variable_declaration( SPAN, VariableDeclarationKind::Var, - self.ctx.ast.vec1(variable_declarator), + ctx.ast.vec1(variable_declarator), false, ); diff --git a/crates/oxc_transformer/src/es2015/mod.rs b/crates/oxc_transformer/src/es2015/mod.rs index 33dfd2056e270..a1ddbdcc809c8 100644 --- a/crates/oxc_transformer/src/es2015/mod.rs +++ b/crates/oxc_transformer/src/es2015/mod.rs @@ -1,18 +1,12 @@ mod arrow_functions; mod options; -use std::rc::Rc; - pub use arrow_functions::{ArrowFunctions, ArrowFunctionsOptions}; pub use options::ES2015Options; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; - -#[allow(dead_code)] pub struct ES2015<'a> { - ctx: Ctx<'a>, options: ES2015Options, // Plugins @@ -20,13 +14,11 @@ pub struct ES2015<'a> { } impl<'a> ES2015<'a> { - pub fn new(options: ES2015Options, ctx: Ctx<'a>) -> Self { + pub fn new(options: ES2015Options) -> Self { Self { arrow_functions: ArrowFunctions::new( options.arrow_function.clone().unwrap_or_default(), - Rc::clone(&ctx), ), - ctx, options, } } diff --git a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs index 5545cc8acf486..f0322c500448f 100644 --- a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs +++ b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs @@ -37,7 +37,7 @@ use oxc_span::SPAN; use oxc_syntax::operator::{AssignmentOperator, BinaryOperator}; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::{context::Ctx, helpers::stack::SparseStack}; +use crate::helpers::stack::SparseStack; /// ES2016: Exponentiation Operator /// @@ -46,7 +46,6 @@ use crate::{context::Ctx, helpers::stack::SparseStack}; /// * /// * pub struct ExponentiationOperator<'a> { - _ctx: Ctx<'a>, var_declarations: SparseStack>>, } @@ -57,8 +56,8 @@ struct Exploded<'a> { } impl<'a> ExponentiationOperator<'a> { - pub fn new(ctx: Ctx<'a>) -> Self { - Self { _ctx: ctx, var_declarations: SparseStack::new() } + pub fn new() -> Self { + Self { var_declarations: SparseStack::new() } } } diff --git a/crates/oxc_transformer/src/es2016/mod.rs b/crates/oxc_transformer/src/es2016/mod.rs index 4fd48ac555d08..39bcb10f4fe68 100644 --- a/crates/oxc_transformer/src/es2016/mod.rs +++ b/crates/oxc_transformer/src/es2016/mod.rs @@ -1,19 +1,13 @@ mod exponentiation_operator; mod options; -use std::rc::Rc; - pub use exponentiation_operator::ExponentiationOperator; pub use options::ES2016Options; use oxc_allocator::Vec; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; - -#[allow(dead_code)] pub struct ES2016<'a> { - ctx: Ctx<'a>, options: ES2016Options, // Plugins @@ -21,8 +15,8 @@ pub struct ES2016<'a> { } impl<'a> ES2016<'a> { - pub fn new(options: ES2016Options, ctx: Ctx<'a>) -> Self { - Self { exponentiation_operator: ExponentiationOperator::new(Rc::clone(&ctx)), ctx, options } + pub fn new(options: ES2016Options) -> Self { + Self { exponentiation_operator: ExponentiationOperator::new(), options } } } diff --git a/crates/oxc_transformer/src/es2018/mod.rs b/crates/oxc_transformer/src/es2018/mod.rs index c3c686ca819e0..512894b946091 100644 --- a/crates/oxc_transformer/src/es2018/mod.rs +++ b/crates/oxc_transformer/src/es2018/mod.rs @@ -1,38 +1,30 @@ mod object_rest_spread; mod options; -use std::rc::Rc; - pub use object_rest_spread::{ObjectRestSpread, ObjectRestSpreadOptions}; pub use options::ES2018Options; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; - -#[allow(dead_code)] -pub struct ES2018<'a> { - ctx: Ctx<'a>, +pub struct ES2018 { options: ES2018Options, // Plugins - object_rest_spread: ObjectRestSpread<'a>, + object_rest_spread: ObjectRestSpread, } -impl<'a> ES2018<'a> { - pub fn new(options: ES2018Options, ctx: Ctx<'a>) -> Self { +impl ES2018 { + pub fn new(options: ES2018Options) -> Self { Self { object_rest_spread: ObjectRestSpread::new( options.object_rest_spread.unwrap_or_default(), - Rc::clone(&ctx), ), - ctx, options, } } } -impl<'a> Traverse<'a> for ES2018<'a> { +impl<'a> Traverse<'a> for ES2018 { 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); diff --git a/crates/oxc_transformer/src/es2018/object_rest_spread/mod.rs b/crates/oxc_transformer/src/es2018/object_rest_spread/mod.rs index 985889b73e5f5..c8bd93765eaed 100644 --- a/crates/oxc_transformer/src/es2018/object_rest_spread/mod.rs +++ b/crates/oxc_transformer/src/es2018/object_rest_spread/mod.rs @@ -26,15 +26,12 @@ //! * Babel plugin implementation: //! * Object rest/spread TC39 proposal: -use std::rc::Rc; - use object_rest::ObjectRest; use object_spread::ObjectSpread; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; use serde::Deserialize; -use crate::context::Ctx; mod object_rest; mod object_spread; @@ -46,28 +43,27 @@ pub struct ObjectRestSpreadOptions { pub(crate) use_built_ins: bool, } -#[allow(dead_code)] -pub struct ObjectRestSpread<'a> { - ctx: Ctx<'a>, +pub struct ObjectRestSpread { + #[allow(dead_code)] options: ObjectRestSpreadOptions, // Plugins - object_spread: ObjectSpread<'a>, - object_rest: ObjectRest<'a>, + object_spread: ObjectSpread, + #[allow(dead_code)] + object_rest: ObjectRest, } -impl<'a> ObjectRestSpread<'a> { - pub fn new(options: ObjectRestSpreadOptions, ctx: Ctx<'a>) -> Self { +impl ObjectRestSpread { + pub fn new(options: ObjectRestSpreadOptions) -> Self { Self { - object_spread: ObjectSpread::new(options, Rc::clone(&ctx)), - object_rest: ObjectRest::new(options, Rc::clone(&ctx)), - ctx, + object_spread: ObjectSpread::new(options), + object_rest: ObjectRest::new(options), options, } } } -impl<'a> Traverse<'a> for ObjectRestSpread<'a> { +impl<'a> Traverse<'a> for ObjectRestSpread { fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { self.object_spread.enter_expression(expr, ctx); } diff --git a/crates/oxc_transformer/src/es2018/object_rest_spread/object_rest.rs b/crates/oxc_transformer/src/es2018/object_rest_spread/object_rest.rs index 8e943d1c3ea37..19a8455ff2ccf 100644 --- a/crates/oxc_transformer/src/es2018/object_rest_spread/object_rest.rs +++ b/crates/oxc_transformer/src/es2018/object_rest_spread/object_rest.rs @@ -25,15 +25,13 @@ //! * Object rest/spread TC39 proposal: use super::ObjectRestSpreadOptions; -use crate::context::Ctx; -pub struct ObjectRest<'a> { - _ctx: Ctx<'a>, +pub struct ObjectRest { _options: ObjectRestSpreadOptions, } -impl<'a> ObjectRest<'a> { - pub fn new(options: ObjectRestSpreadOptions, ctx: Ctx<'a>) -> Self { - Self { _ctx: ctx, _options: options } +impl ObjectRest { + pub fn new(options: ObjectRestSpreadOptions) -> Self { + Self { _options: options } } } diff --git a/crates/oxc_transformer/src/es2018/object_rest_spread/object_spread.rs b/crates/oxc_transformer/src/es2018/object_rest_spread/object_spread.rs index 759e6de388a96..bd05c13b308d1 100644 --- a/crates/oxc_transformer/src/es2018/object_rest_spread/object_spread.rs +++ b/crates/oxc_transformer/src/es2018/object_rest_spread/object_spread.rs @@ -32,19 +32,17 @@ use oxc_span::SPAN; use oxc_traverse::{Traverse, TraverseCtx}; use super::ObjectRestSpreadOptions; -use crate::context::Ctx; -pub struct ObjectSpread<'a> { - _ctx: Ctx<'a>, +pub struct ObjectSpread { options: ObjectRestSpreadOptions, } -impl<'a> ObjectSpread<'a> { - pub fn new(options: ObjectRestSpreadOptions, ctx: Ctx<'a>) -> Self { - Self { _ctx: ctx, options } +impl ObjectSpread { + pub fn new(options: ObjectRestSpreadOptions) -> Self { + Self { options } } } -impl<'a> Traverse<'a> for ObjectSpread<'a> { +impl<'a> Traverse<'a> for ObjectSpread { fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { let Expression::ObjectExpression(obj_expr) = expr else { return; @@ -100,7 +98,7 @@ impl<'a> Traverse<'a> for ObjectSpread<'a> { } } -impl<'a> ObjectSpread<'a> { +impl<'a> ObjectSpread { fn object_assign(symbol_id: Option, ctx: &mut TraverseCtx<'a>) -> Expression<'a> { let ident = ctx.create_reference_id(SPAN, Atom::from("Object"), symbol_id, ReferenceFlags::Read); diff --git a/crates/oxc_transformer/src/es2019/mod.rs b/crates/oxc_transformer/src/es2019/mod.rs index 452e659a7a998..1271b6419a70a 100644 --- a/crates/oxc_transformer/src/es2019/mod.rs +++ b/crates/oxc_transformer/src/es2019/mod.rs @@ -1,31 +1,25 @@ mod optional_catch_binding; mod options; -use std::rc::Rc; - pub use optional_catch_binding::OptionalCatchBinding; pub use options::ES2019Options; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; - -#[allow(dead_code)] -pub struct ES2019<'a> { - ctx: Ctx<'a>, +pub struct ES2019 { options: ES2019Options, // Plugins - optional_catch_binding: OptionalCatchBinding<'a>, + optional_catch_binding: OptionalCatchBinding, } -impl<'a> ES2019<'a> { - pub fn new(options: ES2019Options, ctx: Ctx<'a>) -> Self { - Self { optional_catch_binding: OptionalCatchBinding::new(Rc::clone(&ctx)), ctx, options } +impl ES2019 { + pub fn new(options: ES2019Options) -> Self { + Self { optional_catch_binding: OptionalCatchBinding::new(), options } } } -impl<'a> Traverse<'a> for ES2019<'a> { +impl<'a> Traverse<'a> for ES2019 { fn enter_catch_clause(&mut self, clause: &mut CatchClause<'a>, ctx: &mut TraverseCtx<'a>) { if self.options.optional_catch_binding { self.optional_catch_binding.enter_catch_clause(clause, ctx); diff --git a/crates/oxc_transformer/src/es2019/optional_catch_binding.rs b/crates/oxc_transformer/src/es2019/optional_catch_binding.rs index b8d2d61e22130..337a36a5f5830 100644 --- a/crates/oxc_transformer/src/es2019/optional_catch_binding.rs +++ b/crates/oxc_transformer/src/es2019/optional_catch_binding.rs @@ -37,19 +37,15 @@ use oxc_semantic::SymbolFlags; use oxc_span::SPAN; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; +pub struct OptionalCatchBinding; -pub struct OptionalCatchBinding<'a> { - _ctx: Ctx<'a>, -} - -impl<'a> OptionalCatchBinding<'a> { - pub fn new(ctx: Ctx<'a>) -> Self { - Self { _ctx: ctx } +impl OptionalCatchBinding { + pub fn new() -> Self { + Self } } -impl<'a> Traverse<'a> for OptionalCatchBinding<'a> { +impl<'a> Traverse<'a> for OptionalCatchBinding { /// If CatchClause has no param, add a parameter called `unused`. #[allow(clippy::unused_self)] fn enter_catch_clause(&mut self, clause: &mut CatchClause<'a>, ctx: &mut TraverseCtx<'a>) { diff --git a/crates/oxc_transformer/src/es2020/mod.rs b/crates/oxc_transformer/src/es2020/mod.rs index 5012a9bcee452..094bf02d8b5bd 100644 --- a/crates/oxc_transformer/src/es2020/mod.rs +++ b/crates/oxc_transformer/src/es2020/mod.rs @@ -1,19 +1,13 @@ mod nullish_coalescing_operator; mod options; -use std::rc::Rc; - pub use nullish_coalescing_operator::NullishCoalescingOperator; pub use options::ES2020Options; use oxc_allocator::Vec; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; - -#[allow(dead_code)] pub struct ES2020<'a> { - ctx: Ctx<'a>, options: ES2020Options, // Plugins @@ -21,12 +15,8 @@ pub struct ES2020<'a> { } impl<'a> ES2020<'a> { - pub fn new(options: ES2020Options, ctx: Ctx<'a>) -> Self { - Self { - nullish_coalescing_operator: NullishCoalescingOperator::new(Rc::clone(&ctx)), - ctx, - options, - } + pub fn new(options: ES2020Options) -> Self { + Self { nullish_coalescing_operator: NullishCoalescingOperator::new(), options } } } diff --git a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs index d182d635999e1..843649107ecf6 100644 --- a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs +++ b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs @@ -35,16 +35,15 @@ use oxc_span::SPAN; use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, LogicalOperator}; use oxc_traverse::{Ancestor, Traverse, TraverseCtx}; -use crate::{context::Ctx, helpers::stack::SparseStack}; +use crate::helpers::stack::SparseStack; pub struct NullishCoalescingOperator<'a> { - _ctx: Ctx<'a>, var_declarations: SparseStack>>, } impl<'a> NullishCoalescingOperator<'a> { - pub fn new(ctx: Ctx<'a>) -> Self { - Self { _ctx: ctx, var_declarations: SparseStack::new() } + pub fn new() -> Self { + Self { var_declarations: SparseStack::new() } } } diff --git a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs index 1ff16508d36c5..608fe25e4056d 100644 --- a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs +++ b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs @@ -60,16 +60,15 @@ use oxc_span::SPAN; use oxc_syntax::operator::{AssignmentOperator, LogicalOperator}; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::{context::Ctx, helpers::stack::SparseStack}; +use crate::helpers::stack::SparseStack; pub struct LogicalAssignmentOperators<'a> { - _ctx: Ctx<'a>, var_declarations: SparseStack>>, } impl<'a> LogicalAssignmentOperators<'a> { - pub fn new(ctx: Ctx<'a>) -> Self { - Self { _ctx: ctx, var_declarations: SparseStack::new() } + pub fn new() -> Self { + Self { var_declarations: SparseStack::new() } } } diff --git a/crates/oxc_transformer/src/es2021/mod.rs b/crates/oxc_transformer/src/es2021/mod.rs index 2478da295c2fe..c8d1f7b956498 100644 --- a/crates/oxc_transformer/src/es2021/mod.rs +++ b/crates/oxc_transformer/src/es2021/mod.rs @@ -1,19 +1,13 @@ mod logical_assignment_operators; mod options; -use std::rc::Rc; - pub use logical_assignment_operators::LogicalAssignmentOperators; pub use options::ES2021Options; use oxc_allocator::Vec; use oxc_ast::ast::*; use oxc_traverse::{Traverse, TraverseCtx}; -use crate::context::Ctx; - -#[allow(dead_code)] pub struct ES2021<'a> { - ctx: Ctx<'a>, options: ES2021Options, // Plugins @@ -21,12 +15,8 @@ pub struct ES2021<'a> { } impl<'a> ES2021<'a> { - pub fn new(options: ES2021Options, ctx: Ctx<'a>) -> Self { - Self { - logical_assignment_operators: LogicalAssignmentOperators::new(Rc::clone(&ctx)), - ctx, - options, - } + pub fn new(options: ES2021Options) -> Self { + Self { logical_assignment_operators: LogicalAssignmentOperators::new(), options } } } diff --git a/crates/oxc_transformer/src/lib.rs b/crates/oxc_transformer/src/lib.rs index 539da05fad605..ea7eb224b15a1 100644 --- a/crates/oxc_transformer/src/lib.rs +++ b/crates/oxc_transformer/src/lib.rs @@ -73,8 +73,8 @@ pub struct Transformer<'a> { x1_react: React<'a>, x2_es2021: ES2021<'a>, x2_es2020: ES2020<'a>, - x2_es2019: ES2019<'a>, - x2_es2018: ES2018<'a>, + x2_es2019: ES2019, + x2_es2018: ES2018, x2_es2016: ES2016<'a>, x3_es2015: ES2015<'a>, x4_regexp: RegExp<'a>, @@ -101,12 +101,12 @@ impl<'a> Transformer<'a> { ctx: Rc::clone(&ctx), x0_typescript: TypeScript::new(options.typescript, Rc::clone(&ctx)), x1_react: React::new(options.react, Rc::clone(&ctx)), - x2_es2021: ES2021::new(options.es2021, Rc::clone(&ctx)), - x2_es2020: ES2020::new(options.es2020, Rc::clone(&ctx)), - x2_es2019: ES2019::new(options.es2019, Rc::clone(&ctx)), - x2_es2018: ES2018::new(options.es2018, Rc::clone(&ctx)), - x2_es2016: ES2016::new(options.es2016, Rc::clone(&ctx)), - x3_es2015: ES2015::new(options.es2015, Rc::clone(&ctx)), + x2_es2021: ES2021::new(options.es2021), + x2_es2020: ES2020::new(options.es2020), + x2_es2019: ES2019::new(options.es2019), + x2_es2018: ES2018::new(options.es2018), + x2_es2016: ES2016::new(options.es2016), + x3_es2015: ES2015::new(options.es2015), x4_regexp: RegExp::new(options.regexp, ctx), } }