refactor(ast): rename RestElement to BindingRestElement (#2116)

close: #2115

Author: Dunqing

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> {

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> {

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({})",

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

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

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

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

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

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")]

crates/oxc_parser/src/js/binding.rs

@@ -48,17 +48,17 @@ 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()?;
         let span = self.end_span(span);
 
         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));
             }
         }