diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs
index c74464981..0ee6299d3 100644
--- a/crates/oxc_ast/src/ast/js.rs
+++ b/crates/oxc_ast/src/ast/js.rs
@@ -1484,7 +1484,7 @@ pub struct ObjectPattern<'a> {
     #[cfg_attr(feature = "serde", serde(flatten))]
     pub span: Span,
     pub properties: Vec<'a, BindingProperty<'a>>,
-    pub rest: Option<Box<'a, RestElement<'a>>>,
+    pub rest: Option<Box<'a, BindingRestElement<'a>>>,
 }
 
 impl<'a> ObjectPattern<'a> {
@@ -1514,7 +1514,7 @@ pub struct ArrayPattern<'a> {
     #[cfg_attr(feature = "serde", serde(flatten))]
     pub span: Span,
     pub elements: Vec<'a, Option<BindingPattern<'a>>>,
-    pub rest: Option<Box<'a, RestElement<'a>>>,
+    pub rest: Option<Box<'a, BindingRestElement<'a>>>,
 }
 
 impl<'a> ArrayPattern<'a> {
@@ -1529,7 +1529,7 @@ impl<'a> ArrayPattern<'a> {
 
 #[derive(Debug, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))]
-pub struct RestElement<'a> {
+pub struct BindingRestElement<'a> {
     #[cfg_attr(feature = "serde", serde(flatten))]
     pub span: Span,
     pub argument: BindingPattern<'a>,
@@ -1615,7 +1615,7 @@ pub struct FormalParameters<'a> {
     pub span: Span,
     pub kind: FormalParameterKind,
     pub items: Vec<'a, FormalParameter<'a>>,
-    pub rest: Option<Box<'a, RestElement<'a>>>,
+    pub rest: Option<Box<'a, BindingRestElement<'a>>>,
 }
 
 impl<'a> FormalParameters<'a> {
diff --git a/crates/oxc_ast/src/ast_builder.rs b/crates/oxc_ast/src/ast_builder.rs
index 3c9b69c7c..4cd70d834 100644
--- a/crates/oxc_ast/src/ast_builder.rs
+++ b/crates/oxc_ast/src/ast_builder.rs
@@ -731,7 +731,7 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         kind: FormalParameterKind,
         items: Vec<'a, FormalParameter<'a>>,
-        rest: Option<Box<'a, RestElement<'a>>>,
+        rest: Option<Box<'a, BindingRestElement<'a>>>,
     ) -> Box<'a, FormalParameters<'a>> {
         self.alloc(FormalParameters { span, kind, items, rest })
     }
@@ -938,7 +938,7 @@ impl<'a> AstBuilder<'a> {
         &self,
         span: Span,
         properties: Vec<'a, BindingProperty<'a>>,
-        rest: Option<Box<'a, RestElement<'a>>>,
+        rest: Option<Box<'a, BindingRestElement<'a>>>,
     ) -> BindingPatternKind<'a> {
         BindingPatternKind::ObjectPattern(self.alloc(ObjectPattern { span, properties, rest }))
     }
@@ -966,7 +966,7 @@ impl<'a> AstBuilder<'a> {
         &self,
         span: Span,
         elements: Vec<'a, Option<BindingPattern<'a>>>,
-        rest: Option<Box<'a, RestElement<'a>>>,
+        rest: Option<Box<'a, BindingRestElement<'a>>>,
     ) -> BindingPatternKind<'a> {
         BindingPatternKind::ArrayPattern(self.alloc(ArrayPattern { span, elements, rest }))
     }
@@ -989,8 +989,8 @@ impl<'a> AstBuilder<'a> {
         &self,
         span: Span,
         argument: BindingPattern<'a>,
-    ) -> Box<'a, RestElement<'a>> {
-        self.alloc(RestElement { span, argument })
+    ) -> Box<'a, BindingRestElement<'a>> {
+        self.alloc(BindingRestElement { span, argument })
     }
 
     pub fn property_key_identifier(&self, ident: IdentifierName) -> PropertyKey<'a> {
diff --git a/crates/oxc_ast/src/ast_kind.rs b/crates/oxc_ast/src/ast_kind.rs
index 03cf2c083..2403735cc 100644
--- a/crates/oxc_ast/src/ast_kind.rs
+++ b/crates/oxc_ast/src/ast_kind.rs
@@ -88,7 +88,7 @@ pub enum AstKind<'a> {
     Elision(Span),
     ExpressionArrayElement(&'a Expression<'a>),
     SpreadElement(&'a SpreadElement<'a>),
-    RestElement(&'a RestElement<'a>),
+    BindingRestElement(&'a BindingRestElement<'a>),
 
     Function(&'a Function<'a>),
     FunctionBody(&'a FunctionBody<'a>),
@@ -401,7 +401,7 @@ impl<'a> GetSpan for AstKind<'a> {
             Self::SpreadElement(x) => x.span,
             Self::Elision(span) => *span,
             Self::ExpressionArrayElement(x) => x.span(),
-            Self::RestElement(x) => x.span,
+            Self::BindingRestElement(x) => x.span,
 
             Self::Function(x) => x.span,
             Self::FunctionBody(x) => x.span,
@@ -574,7 +574,7 @@ impl<'a> AstKind<'a> {
             Self::SpreadElement(_) => "SpreadElement".into(),
             Self::Elision(_) => "Elision".into(),
             Self::ExpressionArrayElement(_) => "ExpressionArrayElement".into(),
-            Self::RestElement(_) => "RestElement".into(),
+            Self::BindingRestElement(_) => "BindingRestElement".into(),
 
             Self::Function(x) => format!(
                 "Function({})",
diff --git a/crates/oxc_ast/src/syntax_directed_operations/bound_names.rs b/crates/oxc_ast/src/syntax_directed_operations/bound_names.rs
index 504918d43..35a3a0ba6 100644
--- a/crates/oxc_ast/src/syntax_directed_operations/bound_names.rs
+++ b/crates/oxc_ast/src/syntax_directed_operations/bound_names.rs
@@ -54,7 +54,7 @@ impl<'a> BoundNames for AssignmentPattern<'a> {
     }
 }
 
-impl<'a> BoundNames for RestElement<'a> {
+impl<'a> BoundNames for BindingRestElement<'a> {
     fn bound_names<F: FnMut(&BindingIdentifier)>(&self, f: &mut F) {
         self.argument.bound_names(f);
     }
diff --git a/crates/oxc_ast/src/visit.rs b/crates/oxc_ast/src/visit.rs
index 056b12315..cb8fed207 100644
--- a/crates/oxc_ast/src/visit.rs
+++ b/crates/oxc_ast/src/visit.rs
@@ -1214,8 +1214,8 @@ pub trait Visit<'a>: Sized {
         self.leave_node(kind);
     }
 
-    fn visit_rest_element(&mut self, pat: &RestElement<'a>) {
-        let kind = AstKind::RestElement(self.alloc(pat));
+    fn visit_rest_element(&mut self, pat: &BindingRestElement<'a>) {
+        let kind = AstKind::BindingRestElement(self.alloc(pat));
         self.enter_node(kind);
         self.visit_binding_pattern(&pat.argument);
         self.leave_node(kind);
diff --git a/crates/oxc_ast/src/visit_mut.rs b/crates/oxc_ast/src/visit_mut.rs
index c538a857e..333901214 100644
--- a/crates/oxc_ast/src/visit_mut.rs
+++ b/crates/oxc_ast/src/visit_mut.rs
@@ -1213,8 +1213,8 @@ pub trait VisitMut<'a>: Sized {
         self.leave_node(kind);
     }
 
-    fn visit_rest_element(&mut self, pat: &mut RestElement<'a>) {
-        let kind = AstKind::RestElement(self.alloc(pat));
+    fn visit_rest_element(&mut self, pat: &mut BindingRestElement<'a>) {
+        let kind = AstKind::BindingRestElement(self.alloc(pat));
         self.enter_node(kind);
         self.visit_binding_pattern(&mut pat.argument);
         self.leave_node(kind);
diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs
index 1d90c2c3d..9a2f58589 100644
--- a/crates/oxc_codegen/src/gen.rs
+++ b/crates/oxc_codegen/src/gen.rs
@@ -2100,7 +2100,7 @@ impl<'a, const MINIFY: bool> Gen<MINIFY> for BindingProperty<'a> {
     }
 }
 
-impl<'a, const MINIFY: bool> Gen<MINIFY> for RestElement<'a> {
+impl<'a, const MINIFY: bool> Gen<MINIFY> for BindingRestElement<'a> {
     fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
         p.print_ellipsis();
         self.argument.gen(p, ctx);
diff --git a/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs b/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs
index 5fc4f7da2..fa40260d2 100644
--- a/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_explicit_any.rs
@@ -118,7 +118,7 @@ impl NoExplicitAny {
         debug_assert!(matches!(node.kind(), AstKind::TSAnyKeyword(_)));
         ctx.nodes()
             .iter_parents(node.id())
-            .any(|parent| matches!(parent.kind(), AstKind::RestElement(_)))
+            .any(|parent| matches!(parent.kind(), AstKind::BindingRestElement(_)))
     }
 }
 
diff --git a/crates/oxc_parser/src/diagnostics.rs b/crates/oxc_parser/src/diagnostics.rs
index 997fc1bd8..f06bec9dc 100644
--- a/crates/oxc_parser/src/diagnostics.rs
+++ b/crates/oxc_parser/src/diagnostics.rs
@@ -126,7 +126,7 @@ pub struct ClassDeclaration(#[label] pub Span);
 #[derive(Debug, Error, Diagnostic)]
 #[error("A rest element must be last in a destructuring pattern")]
 #[diagnostic()]
-pub struct RestElementLast(#[label] pub Span);
+pub struct BindingRestElementLast(#[label] pub Span);
 
 #[derive(Debug, Error, Diagnostic)]
 #[error("A rest parameter must be last in a parameter list")]
@@ -141,12 +141,12 @@ pub struct SpreadLastElement(#[label] pub Span);
 #[derive(Debug, Error, Diagnostic)]
 #[error("Unexpected trailing comma after rest element")]
 #[diagnostic()]
-pub struct RestElementTrailingComma(#[label] pub Span);
+pub struct BindingRestElementTrailingComma(#[label] pub Span);
 
 #[derive(Debug, Error, Diagnostic)]
 #[error("Invalid rest element")]
 #[diagnostic(help("Expected identifier in rest element"))]
-pub struct InvalidRestElement(#[label] pub Span);
+pub struct InvalidBindingRestElement(#[label] pub Span);
 
 #[derive(Debug, Error, Diagnostic)]
 #[error("Cannot assign to this expression")]
diff --git a/crates/oxc_parser/src/js/binding.rs b/crates/oxc_parser/src/js/binding.rs
index 592f1a3f0..15317ba9c 100644
--- a/crates/oxc_parser/src/js/binding.rs
+++ b/crates/oxc_parser/src/js/binding.rs
@@ -48,7 +48,7 @@ impl<'a> Parser<'a> {
     }
 
     /// Section 14.3.3 Binding Rest Property
-    pub(crate) fn parse_rest_element(&mut self) -> Result<Box<'a, RestElement<'a>>> {
+    pub(crate) fn parse_rest_element(&mut self) -> Result<Box<'a, BindingRestElement<'a>>> {
         let span = self.start_span();
         self.bump_any(); // advance `...`
         let argument = self.parse_binding_pattern()?;
@@ -56,9 +56,9 @@ impl<'a> Parser<'a> {
 
         if self.at(Kind::Comma) {
             if self.peek_at(Kind::RBrack) {
-                self.error(diagnostics::RestElementTrailingComma(self.cur_token().span()));
+                self.error(diagnostics::BindingRestElementTrailingComma(self.cur_token().span()));
             } else if !self.ctx.has_ambient() {
-                self.error(diagnostics::RestElementLast(span));
+                self.error(diagnostics::BindingRestElementLast(span));
             }
         }
 
diff --git a/crates/oxc_parser/src/js/grammar.rs b/crates/oxc_parser/src/js/grammar.rs
index 26778d8cb..ead6dd775 100644
--- a/crates/oxc_parser/src/js/grammar.rs
+++ b/crates/oxc_parser/src/js/grammar.rs
@@ -80,7 +80,7 @@ impl<'a> CoverGrammar<'a, ArrayExpression<'a>> for ArrayAssignmentTarget<'a> {
                     if i == len - 1 {
                         rest = Some(AssignmentTarget::cover(elem.unbox().argument, p)?);
                         if let Some(span) = expr.trailing_comma {
-                            p.error(diagnostics::RestElementTrailingComma(span));
+                            p.error(diagnostics::BindingRestElementTrailingComma(span));
                         }
                     } else {
                         return Err(diagnostics::SpreadLastElement(elem.span).into());
diff --git a/crates/oxc_parser/src/js/list.rs b/crates/oxc_parser/src/js/list.rs
index 835156cb7..6695a6cf0 100644
--- a/crates/oxc_parser/src/js/list.rs
+++ b/crates/oxc_parser/src/js/list.rs
@@ -61,7 +61,7 @@ impl<'a> SeparatedList<'a> for ObjectExpressionProperties<'a> {
 /// ObjectPattern.properties
 pub struct ObjectPatternProperties<'a> {
     pub elements: Vec<'a, BindingProperty<'a>>,
-    pub rest: Option<oxc_allocator::Box<'a, RestElement<'a>>>,
+    pub rest: Option<oxc_allocator::Box<'a, BindingRestElement<'a>>>,
 }
 
 impl<'a> SeparatedList<'a> for ObjectPatternProperties<'a> {
@@ -81,10 +81,10 @@ impl<'a> SeparatedList<'a> for ObjectPatternProperties<'a> {
         if p.cur_kind() == Kind::Dot3 {
             let rest = p.parse_rest_element()?;
             if !matches!(&rest.argument.kind, BindingPatternKind::BindingIdentifier(_)) {
-                p.error(diagnostics::InvalidRestElement(rest.argument.span()));
+                p.error(diagnostics::InvalidBindingRestElement(rest.argument.span()));
             }
             if let Some(r) = self.rest.replace(rest) {
-                p.error(diagnostics::RestElementLast(r.span));
+                p.error(diagnostics::BindingRestElementLast(r.span));
             }
         } else {
             let prop = p.parse_binding_property()?;
@@ -132,7 +132,7 @@ impl<'a> SeparatedList<'a> for ArrayExpressionList<'a> {
 /// ArrayPattern.elements
 pub struct ArrayPatternList<'a> {
     pub elements: Vec<'a, Option<BindingPattern<'a>>>,
-    pub rest: Option<oxc_allocator::Box<'a, RestElement<'a>>>,
+    pub rest: Option<oxc_allocator::Box<'a, BindingRestElement<'a>>>,
 }
 
 impl<'a> SeparatedList<'a> for ArrayPatternList<'a> {
@@ -156,7 +156,7 @@ impl<'a> SeparatedList<'a> for ArrayPatternList<'a> {
             Kind::Dot3 => {
                 let rest = p.parse_rest_element()?;
                 if let Some(r) = self.rest.replace(rest) {
-                    p.error(diagnostics::RestElementLast(r.span));
+                    p.error(diagnostics::BindingRestElementLast(r.span));
                 }
             }
             _ => {
@@ -233,7 +233,7 @@ impl<'a> SeparatedList<'a> for SequenceExpressionList<'a> {
 /// Function Parameters
 pub struct FormalParameterList<'a> {
     pub elements: Vec<'a, FormalParameter<'a>>,
-    pub rest: Option<oxc_allocator::Box<'a, RestElement<'a>>>,
+    pub rest: Option<oxc_allocator::Box<'a, BindingRestElement<'a>>>,
     pub this_param: Option<TSThisParameter<'a>>,
 }
 
diff --git a/crates/oxc_prettier/src/format/mod.rs b/crates/oxc_prettier/src/format/mod.rs
index 493464b8b..43fcb5295 100644
--- a/crates/oxc_prettier/src/format/mod.rs
+++ b/crates/oxc_prettier/src/format/mod.rs
@@ -2120,7 +2120,7 @@ impl<'a> Format<'a> for BindingProperty<'a> {
     }
 }
 
-impl<'a> Format<'a> for RestElement<'a> {
+impl<'a> Format<'a> for BindingRestElement<'a> {
     fn format(&self, p: &mut Prettier<'a>) -> Doc<'a> {
         array!(p, ss!("..."), format!(p, self.argument))
     }
diff --git a/crates/oxc_semantic/src/binder.rs b/crates/oxc_semantic/src/binder.rs
index e56a65819..eeb1b07e3 100644
--- a/crates/oxc_semantic/src/binder.rs
+++ b/crates/oxc_semantic/src/binder.rs
@@ -182,7 +182,7 @@ impl<'a> Binder for Function<'a> {
     }
 }
 
-impl<'a> Binder for RestElement<'a> {
+impl<'a> Binder for BindingRestElement<'a> {
     // Binds the FormalParameters's rest of a function or method.
     fn bind(&self, builder: &mut SemanticBuilder) {
         let parent_kind = builder.nodes.parent_kind(builder.current_node_id).unwrap();
diff --git a/crates/oxc_semantic/src/builder.rs b/crates/oxc_semantic/src/builder.rs
index dfa587159..e5b9f0b27 100644
--- a/crates/oxc_semantic/src/builder.rs
+++ b/crates/oxc_semantic/src/builder.rs
@@ -450,7 +450,7 @@ impl<'a> SemanticBuilder<'a> {
                     &self.nodes,
                 );
             }
-            AstKind::RestElement(element) => {
+            AstKind::BindingRestElement(element) => {
                 element.bind(self);
             }
             AstKind::FormalParameter(param) => {