refactor(ast): clean up some methods

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(
+    pub fn identifier_reference_expression(&self, ident: IdentifierReference) -> Expression<'a> {
-        &mut 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))
     }
 

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)
     }

crates/oxc_parser/src/js/binding.rs

@@ -30,7 +30,7 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_binding_pattern_identifier(&mut self) -> Result<BindingPatternKind<'a>> {
-        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 {

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<Expression<'a>> {
         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<IdentifierReference> {
@@ -506,7 +506,7 @@ impl<'a> Parser<'a> {
     fn parse_decorator_member_expression(&mut self) -> Result<Expression<'a>> {
         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)?;
         }

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(

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),

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)

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);
     }

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);

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);