refactor: remove paranthesis expression from printer

crates/oxc_ast_lower/src/lib.rs

@@ -579,8 +579,7 @@ impl<'a> AstLower<'a> {
         &mut self,
         expr: &ast::ParenthesizedExpression<'a>,
     ) -> hir::Expression<'a> {
-        let expression = self.lower_expression(&expr.expression);
-        self.hir.parenthesized_expression(expr.span, expression)
+        self.lower_expression(&expr.expression)
     }
 
     fn lower_object_property_kind(

crates/oxc_hir/src/hir.rs

@@ -66,7 +66,6 @@ pub enum Expression<'a> {
     MemberExpression(Box<'a, MemberExpression<'a>>),
     NewExpression(Box<'a, NewExpression<'a>>),
     ObjectExpression(Box<'a, ObjectExpression<'a>>),
-    ParenthesizedExpression(Box<'a, ParenthesizedExpression<'a>>),
     SequenceExpression(Box<'a, SequenceExpression<'a>>),
     TaggedTemplateExpression(Box<'a, TaggedTemplateExpression<'a>>),
     ThisExpression(Box<'a, ThisExpression>),
@@ -950,15 +949,6 @@ pub enum ChainElement<'a> {
     MemberExpression(Box<'a, MemberExpression<'a>>),
 }
 
-/// Parenthesized Expression
-#[derive(Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))]
-pub struct ParenthesizedExpression<'a> {
-    #[cfg_attr(feature = "serde", serde(flatten))]
-    pub span: Span,
-    pub expression: Expression<'a>,
-}
-
 /// Statements
 #[derive(Debug, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))]

crates/oxc_hir/src/hir_builder.rs

@@ -587,16 +587,6 @@ impl<'a> HirBuilder<'a> {
         self.alloc(ObjectProperty { span, kind, key, value, method, shorthand, computed })
     }
 
-    pub fn parenthesized_expression(
-        &self,
-        span: Span,
-        expression: Expression<'a>,
-    ) -> Expression<'a> {
-        Expression::ParenthesizedExpression(
-            self.alloc(ParenthesizedExpression { span, expression }),
-        )
-    }
-
     pub fn private_in_expression(
         &mut self,
         span: Span,

crates/oxc_hir/src/visit_mut.rs

@@ -351,7 +351,6 @@ pub trait VisitMut<'a, 'b>: Sized {
             Expression::MemberExpression(expr) => self.visit_member_expression(expr),
             Expression::NewExpression(expr) => self.visit_new_expression(expr),
             Expression::ObjectExpression(expr) => self.visit_object_expression(expr),
-            Expression::ParenthesizedExpression(expr) => self.visit_parenthesized_expression(expr),
             Expression::PrivateInExpression(expr) => self.visit_private_in_expression(expr),
             Expression::SequenceExpression(expr) => self.visit_sequence_expression(expr),
             Expression::TaggedTemplateExpression(expr) => {
@@ -513,10 +512,6 @@ pub trait VisitMut<'a, 'b>: Sized {
         }
     }
 
-    fn visit_parenthesized_expression(&mut self, expr: &'b mut ParenthesizedExpression<'a>) {
-        self.visit_expression(&mut expr.expression);
-    }
-
     fn visit_private_in_expression(&mut self, expr: &'b mut PrivateInExpression<'a>) {
         self.visit_private_identifier(&mut expr.left);
         self.visit_expression(&mut expr.right);

crates/oxc_minifier/src/compressor/mod.rs

@@ -76,8 +76,7 @@ impl<'a> Compressor<'a> {
         let left = self.hir.literal_number_expression(left);
         let right = self.hir.number_literal(SPAN, 0.0, "0", NumberBase::Decimal);
         let right = self.hir.literal_number_expression(right);
-        let expr = self.hir.binary_expression(SPAN, left, BinaryOperator::Division, right);
-        self.hir.parenthesized_expression(SPAN, expr)
+        self.hir.binary_expression(SPAN, left, BinaryOperator::Division, right)
     }
 
     /* Statements */

crates/oxc_minifier/src/printer/gen.rs

@@ -705,7 +705,6 @@ impl<'a> Gen for Expression<'a> {
             Self::CallExpression(expr) => expr.gen(p),
             Self::ArrayExpression(expr) => expr.gen(p),
             Self::ObjectExpression(expr) => expr.gen(p),
-            Self::ParenthesizedExpression(expr) => expr.gen(p),
             Self::FunctionExpression(expr) => expr.gen(p),
             Self::ArrowExpression(expr) => expr.gen(p),
             Self::YieldExpression(expr) => expr.gen(p),
@@ -1017,14 +1016,6 @@ impl<'a> Gen for PropertyValue<'a> {
     }
 }
 
-impl<'a> Gen for ParenthesizedExpression<'a> {
-    fn gen(&self, p: &mut Printer) {
-        p.print(b'(');
-        self.expression.gen(p);
-        p.print(b')');
-    }
-}
-
 impl<'a> Gen for ArrowExpression<'a> {
     fn gen(&self, p: &mut Printer) {
         if self.r#async {