Skip to content

Commit 0496882

Browse files
overlookmoteloverlookmotel
committed
refactor(traverse): add methods to BoundIdentifier to create Expression::Identifiers
1 parent a1e0d30 commit 0496882

File tree

6 files changed

+147
-61
lines changed

6 files changed

+147
-61
lines changed

‎crates/oxc_transformer/src/es2016/exponentiation_operator.rs‎

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -170,7 +170,7 @@ impl<'a, 'ctx> ExponentiationOperator<'a, 'ctx> {
170170
ctx.create_unbound_reference_id(SPAN, ident.name.clone(), ReferenceFlags::Read),
171171
);
172172
let binding = self.create_temp_var(reference, &mut temp_var_inits, ctx);
173-
ctx.ast.expression_from_identifier_reference(binding.create_read_reference(ctx))
173+
binding.create_read_expression(ctx)
174174
};
175175

176176
(pow_left, temp_var_inits)
@@ -345,10 +345,8 @@ impl<'a, 'ctx> ExponentiationOperator<'a, 'ctx> {
345345
} else {
346346
let owned_prop = ctx.ast.move_expression(prop);
347347
let binding = self.create_temp_var(owned_prop, &mut temp_var_inits, ctx);
348-
let mut create_ident =
349-
|| ctx.ast.expression_from_identifier_reference(binding.create_read_reference(ctx));
350-
*prop = create_ident();
351-
create_ident()
348+
*prop = binding.create_read_expression(ctx);
349+
binding.create_read_expression(ctx)
352350
};
353351

354352
// Complete 2nd member expression
@@ -434,10 +432,8 @@ impl<'a, 'ctx> ExponentiationOperator<'a, 'ctx> {
434432
}
435433

436434
let binding = self.create_temp_var(ctx.ast.move_expression(obj), temp_var_inits, ctx);
437-
let mut create_id =
438-
|| ctx.ast.expression_from_identifier_reference(binding.create_read_reference(ctx));
439-
*obj = create_id();
440-
create_id()
435+
*obj = binding.create_read_expression(ctx);
436+
binding.create_read_expression(ctx)
441437
}
442438

443439
/// `x **= right` -> `x = Math.pow(pow_left, right)` (with provided `pow_left`)
@@ -498,12 +494,12 @@ impl<'a, 'ctx> ExponentiationOperator<'a, 'ctx> {
498494
self.ctx.var_declarations.insert(&binding, None, ctx);
499495

500496
// Add new reference `_name = name` to `temp_var_inits`
501-
let left =
502-
AssignmentTarget::from(ctx.ast.simple_assignment_target_from_identifier_reference(
503-
binding.create_read_write_reference(ctx),
504-
));
505-
let op = AssignmentOperator::Assign;
506-
temp_var_inits.push(ctx.ast.expression_assignment(SPAN, op, left, expr));
497+
temp_var_inits.push(ctx.ast.expression_assignment(
498+
SPAN,
499+
AssignmentOperator::Assign,
500+
binding.create_read_write_target(ctx),
501+
expr,
502+
));
507503

508504
binding
509505
}

‎crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs‎

Lines changed: 2 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -91,17 +91,11 @@ impl<'a, 'ctx> Traverse<'a> for NullishCoalescingOperator<'a, 'ctx> {
9191
SymbolFlags::FunctionScopedVariable,
9292
);
9393

94-
let left =
95-
AssignmentTarget::from(ctx.ast.simple_assignment_target_from_identifier_reference(
96-
binding.create_read_write_reference(ctx),
97-
));
98-
99-
let reference =
100-
ctx.ast.expression_from_identifier_reference(binding.create_read_reference(ctx));
94+
let reference = binding.create_read_expression(ctx);
10195
let assignment = ctx.ast.expression_assignment(
10296
SPAN,
10397
AssignmentOperator::Assign,
104-
left,
98+
binding.create_read_write_target(ctx),
10599
logical_expr.left,
106100
);
107101
let mut new_expr =

‎crates/oxc_transformer/src/es2021/logical_assignment_operators.rs‎

Lines changed: 9 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -153,10 +153,7 @@ impl<'a, 'ctx> LogicalAssignmentOperators<'a, 'ctx> {
153153
if let Some(ident) = self.maybe_generate_memoised(&static_expr.object, ctx) {
154154
// (_o = o).a
155155
let right = ctx.ast.move_expression(&mut static_expr.object);
156-
let target =
157-
AssignmentTarget::from(ctx.ast.simple_assignment_target_from_identifier_reference(
158-
ident.create_read_write_reference(ctx),
159-
));
156+
let target = ident.create_read_write_target(ctx);
160157
let object =
161158
ctx.ast.expression_assignment(SPAN, AssignmentOperator::Assign, target, right);
162159
let left_expr = Expression::from(ctx.ast.member_expression_static(
@@ -169,7 +166,7 @@ impl<'a, 'ctx> LogicalAssignmentOperators<'a, 'ctx> {
169166
// (_o.a = 1)
170167
let assign_expr = ctx.ast.member_expression_static(
171168
SPAN,
172-
ctx.ast.expression_from_identifier_reference(ident.create_read_reference(ctx)),
169+
ident.create_read_expression(ctx),
173170
static_expr.property.clone_in(ctx.ast.allocator),
174171
false,
175172
);
@@ -218,10 +215,7 @@ impl<'a, 'ctx> LogicalAssignmentOperators<'a, 'ctx> {
218215
if let Some(ident) = self.maybe_generate_memoised(&computed_expr.object, ctx) {
219216
// (_o = object)
220217
let right = ctx.ast.move_expression(&mut computed_expr.object);
221-
let target =
222-
AssignmentTarget::from(ctx.ast.simple_assignment_target_from_identifier_reference(
223-
ident.create_read_write_reference(ctx),
224-
));
218+
let target = ident.create_read_write_target(ctx);
225219
let object =
226220
ctx.ast.expression_assignment(SPAN, AssignmentOperator::Assign, target, right);
227221

@@ -230,30 +224,22 @@ impl<'a, 'ctx> LogicalAssignmentOperators<'a, 'ctx> {
230224
// _b = expression
231225
let property = self.maybe_generate_memoised(&expression, ctx);
232226

233-
if let Some(ref property) = property {
234-
let left = AssignmentTarget::from(
235-
ctx.ast.simple_assignment_target_from_identifier_reference(
236-
property.create_read_write_reference(ctx),
237-
),
238-
);
227+
if let Some(property) = &property {
239228
expression = ctx.ast.expression_assignment(
240229
SPAN,
241230
AssignmentOperator::Assign,
242-
left,
231+
property.create_read_write_target(ctx),
243232
expression,
244233
);
245234
}
246235

247236
// _o[_b]
248237
let assign_target = AssignmentTarget::from(ctx.ast.member_expression_computed(
249238
SPAN,
250-
ctx.ast.expression_from_identifier_reference(ident.create_read_reference(ctx)),
239+
ident.create_read_expression(ctx),
251240
property.map_or_else(
252241
|| expression.clone_in(ctx.ast.allocator),
253-
|ident| {
254-
ctx.ast
255-
.expression_from_identifier_reference(ident.create_read_reference(ctx))
256-
},
242+
|ident| ident.create_read_expression(ctx),
257243
),
258244
false,
259245
));
@@ -278,15 +264,10 @@ impl<'a, 'ctx> LogicalAssignmentOperators<'a, 'ctx> {
278264
{
279265
// _key = ++key
280266
if let Some(property_ident) = &property_ident {
281-
let left = AssignmentTarget::from(
282-
ctx.ast.simple_assignment_target_from_identifier_reference(
283-
property_ident.create_read_write_reference(ctx),
284-
),
285-
);
286267
ctx.ast.expression_assignment(
287268
SPAN,
288269
AssignmentOperator::Assign,
289-
left,
270+
property_ident.create_read_write_target(ctx),
290271
ctx.ast.move_expression(&mut expression),
291272
)
292273
} else {
@@ -306,9 +287,7 @@ impl<'a, 'ctx> LogicalAssignmentOperators<'a, 'ctx> {
306287
object,
307288
{
308289
if let Some(property_ident) = property_ident {
309-
ctx.ast.expression_from_identifier_reference(
310-
property_ident.create_read_reference(ctx),
311-
)
290+
property_ident.create_read_expression(ctx)
312291
} else {
313292
expression
314293
}

‎crates/oxc_transformer/src/react/jsx_source.rs‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -147,8 +147,7 @@ impl<'a, 'ctx> ReactJsxSource<'a, 'ctx> {
147147

148148
let filename = {
149149
let key = ctx.ast.property_key_identifier_name(SPAN, "fileName");
150-
let ident = self.get_filename_var(ctx).create_read_reference(ctx);
151-
let value = ctx.ast.expression_from_identifier_reference(ident);
150+
let value = self.get_filename_var(ctx).create_read_expression(ctx);
152151
ctx.ast.object_property_kind_object_property(
153152
SPAN, kind, key, value, None, false, false, false,
154153
)

‎crates/oxc_transformer/src/react/refresh.rs‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -469,9 +469,7 @@ impl<'a, 'ctx> ReactRefresh<'a, 'ctx> {
469469
) -> AssignmentTarget<'a> {
470470
let binding = ctx.generate_uid_in_root_scope("c", SymbolFlags::FunctionScopedVariable);
471471
self.registrations.push((binding.symbol_id, persistent_id));
472-
let ident = binding.create_reference(reference_flags, ctx);
473-
let ident = ctx.ast.simple_assignment_target_from_identifier_reference(ident);
474-
ctx.ast.assignment_target_simple(ident)
472+
binding.create_target(reference_flags, ctx)
475473
}
476474

477475
/// Similar to the `findInnerComponents` function in `react-refresh/babel`.

‎crates/oxc_traverse/src/context/bound_identifier.rs‎

Lines changed: 123 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use oxc_ast::{
2-
ast::{BindingIdentifier, BindingPattern, IdentifierReference},
2+
ast::{AssignmentTarget, BindingIdentifier, BindingPattern, Expression, IdentifierReference},
33
NONE,
44
};
55
use oxc_span::{Atom, Span, SPAN};
@@ -58,11 +58,18 @@ impl<'a> BoundIdentifier<'a> {
5858
ctx.ast.binding_pattern(binding_pattern_kind, NONE, false)
5959
}
6060

61+
// --- Read only ---
62+
6163
/// Create `IdentifierReference` referencing this binding, which is read from, with dummy `Span`
6264
pub fn create_read_reference(&self, ctx: &mut TraverseCtx<'a>) -> IdentifierReference<'a> {
6365
self.create_spanned_read_reference(SPAN, ctx)
6466
}
6567

68+
/// Create `Expression::Identifier` referencing this binding, which is read from, with dummy `Span`
69+
pub fn create_read_expression(&self, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
70+
self.create_spanned_read_expression(SPAN, ctx)
71+
}
72+
6673
/// Create `IdentifierReference` referencing this binding, which is read from, with specified `Span`
6774
pub fn create_spanned_read_reference(
6875
&self,
@@ -72,12 +79,32 @@ impl<'a> BoundIdentifier<'a> {
7279
self.create_spanned_reference(span, ReferenceFlags::Read, ctx)
7380
}
7481

82+
/// Create `Expression::Identifier` referencing this binding, which is read from, with specified `Span`
83+
pub fn create_spanned_read_expression(
84+
&self,
85+
span: Span,
86+
ctx: &mut TraverseCtx<'a>,
87+
) -> Expression<'a> {
88+
self.create_spanned_expression(span, ReferenceFlags::Read, ctx)
89+
}
90+
91+
// --- Write only ---
92+
7593
/// Create `IdentifierReference` referencing this binding, which is written to, with dummy `Span`
76-
#[allow(unused)]
7794
pub fn create_write_reference(&self, ctx: &mut TraverseCtx<'a>) -> IdentifierReference<'a> {
7895
self.create_spanned_write_reference(SPAN, ctx)
7996
}
8097

98+
/// Create `Expression::Identifier` referencing this binding, which is written to, with dummy `Span`
99+
pub fn create_write_expression(&self, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
100+
self.create_spanned_write_expression(SPAN, ctx)
101+
}
102+
103+
/// Create `AssignmentTarget` referencing this binding, which is written to, with dummy `Span`
104+
pub fn create_write_target(&self, ctx: &mut TraverseCtx<'a>) -> AssignmentTarget<'a> {
105+
self.create_spanned_write_target(SPAN, ctx)
106+
}
107+
81108
/// Create `IdentifierReference` referencing this binding, which is written to, with specified `Span`
82109
pub fn create_spanned_write_reference(
83110
&self,
@@ -87,16 +114,47 @@ impl<'a> BoundIdentifier<'a> {
87114
self.create_spanned_reference(span, ReferenceFlags::Write, ctx)
88115
}
89116

117+
/// Create `Expression::Identifier` referencing this binding, which is written to, with specified `Span`
118+
pub fn create_spanned_write_expression(
119+
&self,
120+
span: Span,
121+
ctx: &mut TraverseCtx<'a>,
122+
) -> Expression<'a> {
123+
self.create_spanned_expression(span, ReferenceFlags::Write, ctx)
124+
}
125+
126+
/// Create `AssignmentTarget` referencing this binding, which is written to, with specified `Span`
127+
pub fn create_spanned_write_target(
128+
&self,
129+
span: Span,
130+
ctx: &mut TraverseCtx<'a>,
131+
) -> AssignmentTarget<'a> {
132+
self.create_spanned_target(span, ReferenceFlags::Write, ctx)
133+
}
134+
135+
// --- Read and write ---
136+
90137
/// Create `IdentifierReference` referencing this binding, which is read from + written to,
91138
/// with dummy `Span`
92-
#[allow(unused)]
93139
pub fn create_read_write_reference(
94140
&self,
95141
ctx: &mut TraverseCtx<'a>,
96142
) -> IdentifierReference<'a> {
97143
self.create_spanned_read_write_reference(SPAN, ctx)
98144
}
99145

146+
/// Create `Expression::Identifier` referencing this binding, which is read from + written to,
147+
/// with dummy `Span`
148+
pub fn create_read_write_expression(&self, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
149+
self.create_spanned_read_write_expression(SPAN, ctx)
150+
}
151+
152+
/// Create `AssignmentTarget` referencing this binding, which is read from + written to,
153+
/// with dummy `Span`
154+
pub fn create_read_write_target(&self, ctx: &mut TraverseCtx<'a>) -> AssignmentTarget<'a> {
155+
self.create_spanned_read_write_target(SPAN, ctx)
156+
}
157+
100158
/// Create `IdentifierReference` referencing this binding, which is read from + written to,
101159
/// with specified `Span`
102160
pub fn create_spanned_read_write_reference(
@@ -107,6 +165,28 @@ impl<'a> BoundIdentifier<'a> {
107165
self.create_spanned_reference(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx)
108166
}
109167

168+
/// Create `Expression::Identifier` referencing this binding, which is read from + written to,
169+
/// with specified `Span`
170+
pub fn create_spanned_read_write_expression(
171+
&self,
172+
span: Span,
173+
ctx: &mut TraverseCtx<'a>,
174+
) -> Expression<'a> {
175+
self.create_spanned_expression(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx)
176+
}
177+
178+
/// Create `AssignmentTarget` referencing this binding, which is read from + written to,
179+
/// with specified `Span`
180+
pub fn create_spanned_read_write_target(
181+
&self,
182+
span: Span,
183+
ctx: &mut TraverseCtx<'a>,
184+
) -> AssignmentTarget<'a> {
185+
self.create_spanned_target(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx)
186+
}
187+
188+
// --- Specified ReferenceFlags ---
189+
110190
/// Create `IdentifierReference` referencing this binding, with specified `ReferenceFlags`
111191
pub fn create_reference(
112192
&self,
@@ -116,6 +196,24 @@ impl<'a> BoundIdentifier<'a> {
116196
self.create_spanned_reference(SPAN, flags, ctx)
117197
}
118198

199+
/// Create `Expression::Identifier` referencing this binding, with specified `ReferenceFlags`
200+
pub fn create_expression(
201+
&self,
202+
flags: ReferenceFlags,
203+
ctx: &mut TraverseCtx<'a>,
204+
) -> Expression<'a> {
205+
self.create_spanned_expression(SPAN, flags, ctx)
206+
}
207+
208+
/// Create `AssignmentTarget` referencing this binding, with specified `ReferenceFlags`
209+
pub fn create_target(
210+
&self,
211+
flags: ReferenceFlags,
212+
ctx: &mut TraverseCtx<'a>,
213+
) -> AssignmentTarget<'a> {
214+
self.create_spanned_target(SPAN, flags, ctx)
215+
}
216+
119217
/// Create `IdentifierReference` referencing this binding, with specified `Span` and `ReferenceFlags`
120218
pub fn create_spanned_reference(
121219
&self,
@@ -125,4 +223,26 @@ impl<'a> BoundIdentifier<'a> {
125223
) -> IdentifierReference<'a> {
126224
ctx.create_bound_reference_id(span, self.name.clone(), self.symbol_id, flags)
127225
}
226+
227+
/// Create `Expression::Identifier` referencing this binding, with specified `Span` and `ReferenceFlags`
228+
pub fn create_spanned_expression(
229+
&self,
230+
span: Span,
231+
flags: ReferenceFlags,
232+
ctx: &mut TraverseCtx<'a>,
233+
) -> Expression<'a> {
234+
let ident = self.create_spanned_reference(span, flags, ctx);
235+
ctx.ast.expression_from_identifier_reference(ident)
236+
}
237+
238+
/// Create `Expression::Identifier` referencing this binding, with specified `Span` and `ReferenceFlags`
239+
pub fn create_spanned_target(
240+
&self,
241+
span: Span,
242+
flags: ReferenceFlags,
243+
ctx: &mut TraverseCtx<'a>,
244+
) -> AssignmentTarget<'a> {
245+
let ident = self.create_spanned_reference(span, flags, ctx);
246+
AssignmentTarget::from(ctx.ast.simple_assignment_target_from_identifier_reference(ident))
247+
}
128248
}

0 commit comments

Comments
 (0)