From 47872200e5f5bcb9fa8fcb075386acb99d3969f9 Mon Sep 17 00:00:00 2001 From: Boshen Date: Sun, 15 Oct 2023 10:49:35 +0800 Subject: [PATCH] refactor(ast): clean up some methods --- crates/oxc_ast/src/ast_builder.rs | 22 +++++-------------- crates/oxc_minifier/src/compressor/fold.rs | 2 +- crates/oxc_parser/src/js/binding.rs | 4 ++-- crates/oxc_parser/src/js/expression.rs | 4 ++-- crates/oxc_parser/src/js/function.rs | 2 +- crates/oxc_parser/src/ts/statement.rs | 2 +- .../src/es2016/exponentiation_operator.rs | 2 +- .../src/es2019/optional_catch_binding.rs | 2 +- .../es2021/logical_assignment_operators.rs | 2 +- .../src/regexp/regexp_flags.rs | 2 +- 10 files changed, 17 insertions(+), 27 deletions(-) diff --git a/crates/oxc_ast/src/ast_builder.rs b/crates/oxc_ast/src/ast_builder.rs index da62e5bff..55cbc5017 100644 --- a/crates/oxc_ast/src/ast_builder.rs +++ b/crates/oxc_ast/src/ast_builder.rs @@ -108,10 +108,6 @@ impl<'a> AstBuilder<'a> { BooleanLiteral { span, value } } - pub fn null_literal(&self, span: Span) -> NullLiteral { - NullLiteral { span } - } - pub fn bigint_literal(&self, span: Span, value: BigInt) -> BigintLiteral { BigintLiteral { span, value } } @@ -166,23 +162,14 @@ impl<'a> AstBuilder<'a> { Expression::BigintLiteral(self.alloc(literal)) } - pub fn literal_template_expression(&mut self, literal: TemplateLiteral<'a>) -> Expression<'a> { + pub fn literal_template_expression(&self, literal: TemplateLiteral<'a>) -> Expression<'a> { Expression::TemplateLiteral(self.alloc(literal)) } - pub fn identifier_reference_expression( - &mut self, - ident: IdentifierReference, - ) -> Expression<'a> { + pub fn identifier_reference_expression(&self, ident: IdentifierReference) -> Expression<'a> { Expression::Identifier(self.alloc(ident)) } - /* ---------- Identifiers ---------- */ - - pub fn identifier_expression(&self, identifier: IdentifierReference) -> Expression<'a> { - Expression::Identifier(self.alloc(identifier)) - } - /* ---------- Statements ---------- */ pub fn directive(&self, span: Span, expression: StringLiteral, directive: Atom) -> Directive { @@ -865,7 +852,10 @@ impl<'a> AstBuilder<'a> { BindingPattern { kind, type_annotation, optional } } - pub fn binding_identifier(&self, identifier: BindingIdentifier) -> BindingPatternKind<'a> { + pub fn binding_pattern_identifier( + &self, + identifier: BindingIdentifier, + ) -> BindingPatternKind<'a> { BindingPatternKind::BindingIdentifier(self.alloc(identifier)) } diff --git a/crates/oxc_minifier/src/compressor/fold.rs b/crates/oxc_minifier/src/compressor/fold.rs index 41797f90d..af6e71932 100644 --- a/crates/oxc_minifier/src/compressor/fold.rs +++ b/crates/oxc_minifier/src/compressor/fold.rs @@ -933,7 +933,7 @@ impl<'a> Compressor<'a> { } fn move_out_expression(&mut self, expr: &mut Expression<'a>) -> Expression<'a> { - let null_literal = self.ast.null_literal(expr.span()); + let null_literal = NullLiteral::new(expr.span()); let null_expr = self.ast.literal_null_expression(null_literal); mem::replace(expr, null_expr) } diff --git a/crates/oxc_parser/src/js/binding.rs b/crates/oxc_parser/src/js/binding.rs index 42eda1e2c..592f1a3f0 100644 --- a/crates/oxc_parser/src/js/binding.rs +++ b/crates/oxc_parser/src/js/binding.rs @@ -30,7 +30,7 @@ impl<'a> Parser<'a> { } fn parse_binding_pattern_identifier(&mut self) -> Result> { - self.parse_binding_identifier().map(|ident| self.ast.binding_identifier(ident)) + self.parse_binding_identifier().map(|ident| self.ast.binding_pattern_identifier(ident)) } /// Section 14.3.3 Object Binding Pattern @@ -91,7 +91,7 @@ impl<'a> Parser<'a> { if let PropertyKey::Identifier(ident) = &key { shorthand = true; let binding_identifier = BindingIdentifier::new(ident.span, ident.name.clone()); - let identifier = self.ast.binding_identifier(binding_identifier); + let identifier = self.ast.binding_pattern_identifier(binding_identifier); let left = self.ast.binding_pattern(identifier, None, false); self.with_context(Context::In, |p| p.parse_initializer(span, left))? } else { diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs index f6b1dd6c2..e3040d0c6 100644 --- a/crates/oxc_parser/src/js/expression.rs +++ b/crates/oxc_parser/src/js/expression.rs @@ -47,7 +47,7 @@ impl<'a> Parser<'a> { /// `PrimaryExpression`: Identifier Reference pub(crate) fn parse_identifier_expression(&mut self) -> Result> { let ident = self.parse_identifier_reference()?; - Ok(self.ast.identifier_expression(ident)) + Ok(self.ast.identifier_reference_expression(ident)) } pub(crate) fn parse_identifier_reference(&mut self) -> Result { @@ -506,7 +506,7 @@ impl<'a> Parser<'a> { fn parse_decorator_member_expression(&mut self) -> Result> { let lhs_span = self.start_span(); let lhs = self.parse_identifier_reference()?; - let mut lhs = self.ast.identifier_expression(lhs); + let mut lhs = self.ast.identifier_reference_expression(lhs); while self.at(Kind::Dot) { lhs = self.parse_static_member_expression(lhs_span, lhs, false)?; } diff --git a/crates/oxc_parser/src/js/function.rs b/crates/oxc_parser/src/js/function.rs index 48933f2d8..0ccf5bbde 100644 --- a/crates/oxc_parser/src/js/function.rs +++ b/crates/oxc_parser/src/js/function.rs @@ -215,7 +215,7 @@ impl<'a> Parser<'a> { self.ctx = self.ctx.union_await_if(r#async).union_yield_if(generator); let params_span = self.start_span(); let param = self.parse_binding_identifier()?; - let ident = self.ast.binding_identifier(param); + let ident = self.ast.binding_pattern_identifier(param); let pattern = self.ast.binding_pattern(ident, None, false); let params_span = self.end_span(params_span); let formal_parameter = self.ast.formal_parameter( diff --git a/crates/oxc_parser/src/ts/statement.rs b/crates/oxc_parser/src/ts/statement.rs index cdf84e07e..d196dd955 100644 --- a/crates/oxc_parser/src/ts/statement.rs +++ b/crates/oxc_parser/src/ts/statement.rs @@ -431,7 +431,7 @@ impl<'a> Parser<'a> { let span = self.start_span(); let (ident_span, name) = self.parse_identifier_kind(Kind::This); let type_annotation = self.parse_ts_type_annotation()?; - let kind = self.ast.binding_identifier(BindingIdentifier::new(ident_span, name)); + let kind = self.ast.binding_pattern_identifier(BindingIdentifier::new(ident_span, name)); let binding = self.ast.binding_pattern(kind, type_annotation, /* optional */ false); Ok(self.ast.formal_parameter( self.end_span(span), diff --git a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs index 69e040f8e..5e52275c3 100644 --- a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs +++ b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs @@ -28,7 +28,7 @@ impl<'a> ExponentiationOperator<'a> { let right = self.ast.move_expression(&mut binary_expression.right); // Math.pow let ident_math = IdentifierReference::new(Span::default(), "Math".into()); - let object = self.ast.identifier_expression(ident_math); + let object = self.ast.identifier_reference_expression(ident_math); let property = IdentifierName::new(Span::default(), "pow".into()); let callee = self.ast.static_member_expression(Span::default(), object, property, false); // Math.pow(left, right) diff --git a/crates/oxc_transformer/src/es2019/optional_catch_binding.rs b/crates/oxc_transformer/src/es2019/optional_catch_binding.rs index e6e146ad8..46b15f28c 100644 --- a/crates/oxc_transformer/src/es2019/optional_catch_binding.rs +++ b/crates/oxc_transformer/src/es2019/optional_catch_binding.rs @@ -22,7 +22,7 @@ impl<'a> OptionalCatchBinding<'a> { return; } let binding_identifier = BindingIdentifier::new(Span::default(), "_unused".into()); - let binding_pattern_kind = self.ast.binding_identifier(binding_identifier); + let binding_pattern_kind = self.ast.binding_pattern_identifier(binding_identifier); let binding_pattern = self.ast.binding_pattern(binding_pattern_kind, None, false); clause.param = Some(binding_pattern); } diff --git a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs index 34301daf6..8e4aa20f8 100644 --- a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs +++ b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs @@ -35,7 +35,7 @@ impl<'a> LogicalAssignmentOperators<'a> { let left2 = match &assignment_expr.left { AssignmentTarget::SimpleAssignmentTarget(target) => match target { SimpleAssignmentTarget::AssignmentTargetIdentifier(ident) => { - self.ast.identifier_expression((*ident).clone()) + self.ast.identifier_reference_expression((*ident).clone()) } SimpleAssignmentTarget::MemberAssignmentTarget(member_expr) => { let member_expr = self.ast.copy(&**member_expr); diff --git a/crates/oxc_transformer/src/regexp/regexp_flags.rs b/crates/oxc_transformer/src/regexp/regexp_flags.rs index 83c1e7075..70ade676a 100644 --- a/crates/oxc_transformer/src/regexp/regexp_flags.rs +++ b/crates/oxc_transformer/src/regexp/regexp_flags.rs @@ -36,7 +36,7 @@ impl<'a> RegexpFlags<'a> { return; } let ident = IdentifierReference::new(Span::default(), Atom::from("RegExp")); - let callee = self.ast.identifier_expression(ident); + let callee = self.ast.identifier_reference_expression(ident); let pattern = self.ast.string_literal(Span::default(), Atom::from(regex.pattern.as_str())); let flags = self.ast.string_literal(Span::default(), Atom::from(regex.flags.to_string())); let pattern_literal = self.ast.literal_string_expression(pattern);