From 97999ddfc8e2cedbe406775e43dd725fe5048075 Mon Sep 17 00:00:00 2001 From: Dunqing Date: Wed, 25 Dec 2024 16:24:30 +0800 Subject: [PATCH] refactor(transformer/class-properties): move supers to super_converter --- .../src/es2022/class_properties/mod.rs | 6 +-- .../static_block_and_prop_init.rs | 35 ++++++++++----- .../{supers.rs => super_converter.rs} | 44 +++++++++++++++---- 3 files changed, 62 insertions(+), 23 deletions(-) rename crates/oxc_transformer/src/es2022/class_properties/{supers.rs => super_converter.rs} (93%) diff --git a/crates/oxc_transformer/src/es2022/class_properties/mod.rs b/crates/oxc_transformer/src/es2022/class_properties/mod.rs index 748338cd2c88c2..8cf5f47a797a65 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/mod.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/mod.rs @@ -183,8 +183,8 @@ //! * `static_block_and_prop_init.rs`: Transform of static property initializers and static blocks. //! * `computed_key.rs`: Transform of property/method computed keys. //! * `private_field.rs`: Transform of private fields (`this.#prop`). -//! * `private_method.rs`: Transform of private methods (`this.#method()`). -//! * `super.rs`: Transform `super` expressions. +//! * `private_method.rs`: Transform of private methods (`this.#method()`). +//! * `super_converter.rs`: Transform `super` expressions. //! * `class_details.rs`: Structures containing details of classes and private properties. //! * `class_bindings.rs`: Structure containing bindings for class name and temp var. //! * `utils.rs`: Utility functions. @@ -218,7 +218,7 @@ mod private_field; mod private_method; mod prop_decl; mod static_block_and_prop_init; -mod supers; +mod super_converter; mod utils; use class_bindings::ClassBindings; use class_details::{ClassDetails, ClassesStack, PrivateProp, ResolvedPrivateProp}; diff --git a/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs b/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs index 432905273ea5ba..31b6105ff73db0 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs @@ -11,7 +11,10 @@ use oxc_syntax::scope::{ScopeFlags, ScopeId}; use oxc_traverse::TraverseCtx; use super::super::ClassStaticBlock; -use super::ClassProperties; +use super::{ + super_converter::{ClassPropertiesSuperConverter, ClassPropertiesSuperConverterMode}, + ClassProperties, +}; impl<'a, 'ctx> ClassProperties<'a, 'ctx> { /// Transform static property initializer. @@ -179,8 +182,8 @@ struct StaticVisitor<'a, 'ctx, 'v> { /// the `ScopeId` of the old static block, so we don't need to reparent scopes anyway, /// so `scope_depth` is ignored. scope_depth: u32, - /// Main transform instance. - class_properties: &'v mut ClassProperties<'a, 'ctx>, + /// Converter for `super` expressions. + super_converter: ClassPropertiesSuperConverter<'a, 'ctx, 'v>, /// `TraverseCtx` object. ctx: &'v mut TraverseCtx<'a>, } @@ -200,7 +203,17 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { #[expect(clippy::bool_to_int_with_if)] let scope_depth = if reparent_scopes { 0 } else { 1 }; - Self { walk_deep, make_sloppy_mode, this_depth: 0, scope_depth, class_properties, ctx } + Self { + walk_deep, + make_sloppy_mode, + this_depth: 0, + scope_depth, + super_converter: ClassPropertiesSuperConverter::new( + ClassPropertiesSuperConverterMode::Static, + class_properties, + ), + ctx, + } } } @@ -476,7 +489,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { /// Replace `this` with reference to temp var for class. fn replace_this_with_temp_var(&mut self, expr: &mut Expression<'a>, span: Span) { if self.this_depth == 0 { - let class_details = self.class_properties.current_class_mut(); + let class_details = self.super_converter.class_properties.current_class_mut(); let temp_binding = class_details.bindings.get_or_init_static_binding(self.ctx); *expr = temp_binding.create_spanned_read_expression(span, self.ctx); } @@ -485,7 +498,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { /// Replace reference to class name with reference to temp var for class. fn replace_class_name_with_temp_var(&mut self, ident: &mut IdentifierReference<'a>) { // Check identifier is reference to class name - let class_details = self.class_properties.current_class_mut(); + let class_details = self.super_converter.class_properties.current_class_mut(); let class_name_symbol_id = class_details.bindings.name_symbol_id(); let Some(class_name_symbol_id) = class_name_symbol_id else { return }; @@ -527,7 +540,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { #[inline] fn transform_static_member_expression_if_super(&mut self, expr: &mut Expression<'a>) { if self.this_depth == 0 { - self.class_properties.transform_static_member_expression(expr, self.ctx); + self.super_converter.transform_static_member_expression(expr, self.ctx); } } @@ -535,7 +548,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { #[inline] fn transform_computed_member_expression_if_super(&mut self, expr: &mut Expression<'a>) { if self.this_depth == 0 { - self.class_properties.transform_computed_member_expression(expr, self.ctx); + self.super_converter.transform_computed_member_expression(expr, self.ctx); } } @@ -546,7 +559,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { call_expr: &mut CallExpression<'a>, ) { if self.this_depth == 0 { - self.class_properties + self.super_converter .transform_call_expression_for_super_member_expr(call_expr, self.ctx); } } @@ -559,7 +572,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { expr: &mut Expression<'a>, ) { if self.this_depth == 0 { - self.class_properties + self.super_converter .transform_assignment_expression_for_super_assignment_target(expr, self.ctx); } } @@ -572,7 +585,7 @@ impl<'a, 'ctx, 'v> StaticVisitor<'a, 'ctx, 'v> { expr: &mut Expression<'a>, ) { if self.this_depth == 0 { - self.class_properties + self.super_converter .transform_update_expression_for_super_assignment_target(expr, self.ctx); } } diff --git a/crates/oxc_transformer/src/es2022/class_properties/supers.rs b/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs similarity index 93% rename from crates/oxc_transformer/src/es2022/class_properties/supers.rs rename to crates/oxc_transformer/src/es2022/class_properties/super_converter.rs index 2e5c584776e86c..c6735c5387c0ed 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/supers.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs @@ -10,7 +10,29 @@ use crate::Helper; use super::{utils::create_assignment, ClassProperties}; -impl<'a, 'ctx> ClassProperties<'a, 'ctx> { +#[derive(Debug)] +pub(super) enum ClassPropertiesSuperConverterMode { + // `static prop` or `static {}` + Static, +} + +/// Convert `super` expressions. +pub(super) struct ClassPropertiesSuperConverter<'a, 'ctx, 'v> { + #[expect(unused)] + mode: ClassPropertiesSuperConverterMode, + pub(super) class_properties: &'v mut ClassProperties<'a, 'ctx>, +} + +impl<'a, 'ctx, 'v> ClassPropertiesSuperConverter<'a, 'ctx, 'v> { + pub(super) fn new( + mode: ClassPropertiesSuperConverterMode, + class_properties: &'v mut ClassProperties<'a, 'ctx>, + ) -> Self { + Self { mode, class_properties } + } +} + +impl<'a, 'ctx, 'v> ClassPropertiesSuperConverter<'a, 'ctx, 'v> { /// Transform static member expression where object is `super`. /// /// `super.prop` -> `_superPropGet(_Class, "prop", _Class)` @@ -238,7 +260,7 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { self.create_super_prop_set(span, property, value, ctx) } else { // Make 2 copies of `object` - let (property1, property2) = self.duplicate_object(property, ctx); + let (property1, property2) = self.class_properties.duplicate_object(property, ctx); if let Some(operator) = operator.to_binary_operator() { // `super[prop] += value` @@ -471,13 +493,14 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { // Make 2 copies of `property` - let (property1, property2) = self.duplicate_object(property, ctx); + let (property1, property2) = self.class_properties.duplicate_object(property, ctx); // `_superPropGet(_Class, prop, _Class)` let get_call = self.create_super_prop_get(SPAN, property2, false, ctx); // `_super$prop = _superPropGet(_Class, prop, _Class)` - let temp_binding = self.ctx.var_declarations.create_uid_var(temp_var_name_base, ctx); + let temp_binding = + self.class_properties.ctx.var_declarations.create_uid_var(temp_var_name_base, ctx); let assignment = create_assignment(&temp_binding, get_call, ctx); // `++_super$prop` / `_super$prop++` (reusing existing `UpdateExpression`) @@ -498,7 +521,8 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { } else { // Source = `super.prop++` (postfix `++`) // `_super$prop2 = _super$prop++` - let temp_binding2 = self.ctx.var_declarations.create_uid_var(temp_var_name_base, ctx); + let temp_binding2 = + self.class_properties.ctx.var_declarations.create_uid_var(temp_var_name_base, ctx); let assignment2 = create_assignment(&temp_binding2, update_expr, ctx); // `(_super$prop = _superPropGet(_Class, prop, _Class), _super$prop2 = _super$prop++, _super$prop)` @@ -533,7 +557,8 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { is_callee: bool, ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { - let temp_binding = self.current_class_mut().bindings.get_or_init_static_binding(ctx); + let temp_binding = + self.class_properties.current_class_mut().bindings.get_or_init_static_binding(ctx); let ident1 = Argument::from(temp_binding.create_read_expression(ctx)); let ident2 = Argument::from(temp_binding.create_read_expression(ctx)); @@ -549,7 +574,7 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { }; // `_superPropGet(_Class, prop, _Class)` or `_superPropGet(_Class, prop, _Class, 2)` - self.ctx.helper_call_expr(Helper::SuperPropGet, span, arguments, ctx) + self.class_properties.ctx.helper_call_expr(Helper::SuperPropGet, span, arguments, ctx) } /// `_superPropSet(_Class, prop, value, _Class, 1)` @@ -560,7 +585,8 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { value: Expression<'a>, ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { - let temp_binding = self.current_class_mut().bindings.get_or_init_static_binding(ctx); + let temp_binding = + self.class_properties.current_class_mut().bindings.get_or_init_static_binding(ctx); let arguments = ctx.ast.vec_from_array([ Argument::from(temp_binding.create_read_expression(ctx)), Argument::from(property), @@ -573,6 +599,6 @@ impl<'a, 'ctx> ClassProperties<'a, 'ctx> { NumberBase::Decimal, )), ]); - self.ctx.helper_call_expr(Helper::SuperPropSet, span, arguments, ctx) + self.class_properties.ctx.helper_call_expr(Helper::SuperPropSet, span, arguments, ctx) } }