diff --git a/crates/oxc_prettier/src/lib.rs b/crates/oxc_prettier/src/lib.rs
index 1198c6f50..a68ecd83f 100644
--- a/crates/oxc_prettier/src/lib.rs
+++ b/crates/oxc_prettier/src/lib.rs
@@ -56,7 +56,7 @@ pub struct Prettier<'a> {
 
     /// The stack of AST Nodes
     /// See <https://github.com/prettier/prettier/blob/main/src/common/ast-path.js>
-    nodes: Vec<AstKind<'a>>,
+    stack: Vec<AstKind<'a>>,
 
     group_id_builder: GroupIdBuilder,
     args: PrettierArgs,
@@ -81,7 +81,7 @@ impl<'a> Prettier<'a> {
             source_text,
             options,
             trivias: trivias.comments.into_iter().peekable(),
-            nodes: vec![],
+            stack: vec![],
             group_id_builder: GroupIdBuilder::default(),
             args: PrettierArgs::default(),
         }
@@ -97,30 +97,30 @@ impl<'a> Prettier<'a> {
     }
 
     fn enter_node(&mut self, kind: AstKind<'a>) {
-        self.nodes.push(kind);
+        self.stack.push(kind);
     }
 
     fn leave_node(&mut self) {
-        self.nodes.pop();
+        self.stack.pop();
     }
 
     fn current_kind(&self) -> AstKind<'a> {
-        self.nodes[self.nodes.len() - 1]
+        self.stack[self.stack.len() - 1]
     }
 
     fn parent_kind(&self) -> AstKind<'a> {
-        self.nodes[self.nodes.len() - 2]
+        self.stack[self.stack.len() - 2]
     }
 
     fn parent_parent_kind(&self) -> Option<AstKind<'a>> {
-        let len = self.nodes.len();
-        (len >= 3).then(|| self.nodes[len - 3])
+        let len = self.stack.len();
+        (len >= 3).then(|| self.stack[len - 3])
     }
 
     #[allow(unused)]
     fn nth_parent_kind(&self, n: usize) -> Option<AstKind<'a>> {
-        let len = self.nodes.len();
-        (len > n).then(|| self.nodes[len - n - 1])
+        let len = self.stack.len();
+        (len > n).then(|| self.stack[len - n - 1])
     }
 
     /// A hack for erasing the lifetime requirement.
diff --git a/crates/oxc_prettier/src/needs_parens.rs b/crates/oxc_prettier/src/needs_parens.rs
index 7767f4837..89bca702b 100644
--- a/crates/oxc_prettier/src/needs_parens.rs
+++ b/crates/oxc_prettier/src/needs_parens.rs
@@ -252,7 +252,7 @@ impl<'a> Prettier<'a> {
 
     fn check_object_expression(&self, obj_expr: &ObjectExpression<'a>) -> bool {
         let mut arrow_expr = None;
-        for kind in self.nodes.iter().rev() {
+        for kind in self.stack.iter().rev() {
             if let AstKind::ArrowExpression(e) = kind {
                 e.get_expression();
                 arrow_expr = Some(e);
@@ -295,7 +295,7 @@ impl<'a> Prettier<'a> {
         if ident.name != "let" {
             return false;
         }
-        for kind in self.nodes.iter().rev() {
+        for kind in self.stack.iter().rev() {
             if let AstKind::ForOfStatement(stmt) = kind {
                 if let ForStatementLeft::AssignmentTarget(
                     AssignmentTarget::SimpleAssignmentTarget(
@@ -325,7 +325,7 @@ impl<'a> Prettier<'a> {
         if !matches!(&expr.object, Expression::Identifier(ident) if ident.name == "let") {
             return false;
         }
-        let Some(statement) = self.nodes.iter().rev().find(|node| {
+        let Some(statement) = self.stack.iter().rev().find(|node| {
             matches!(
                 node,
                 AstKind::ExpressionStatement(_)
@@ -360,7 +360,7 @@ impl<'a> Prettier<'a> {
     }
 
     fn check_object_function_class(&self, span: Span) -> bool {
-        for ast_kind in self.nodes.iter().rev() {
+        for ast_kind in self.stack.iter().rev() {
             if let AstKind::ExpressionStatement(e) = ast_kind {
                 if Self::starts_with_no_lookahead_token(&e.expression, span) {
                     return true;
@@ -524,9 +524,9 @@ impl<'a> Prettier<'a> {
         }
 
         let lhs = Self::get_left_side_path_name(kind);
-        self.nodes.push(lhs);
+        self.stack.push(lhs);
         let result = self.should_wrap_function_for_export_default();
-        self.nodes.pop();
+        self.stack.pop();
         result
     }
 
@@ -563,7 +563,7 @@ impl<'a> Prettier<'a> {
 
     fn is_path_in_for_statement_initializer(&self, span: Span) -> bool {
         let mut node = Some(span);
-        let mut parents = self.nodes.iter().rev();
+        let mut parents = self.stack.iter().rev();
         while let Some(n) = node {
             let parent = parents.next();
             if let Some(AstKind::ForStatement(stmt)) = parent {