From 942b2ba0844811d760c60e1be9814fcfc9f415af Mon Sep 17 00:00:00 2001 From: overlookmotel Date: Mon, 22 Apr 2024 19:05:11 +0100 Subject: [PATCH] refactor(ast): add array element `Elision` type (#3074) Pure refactor. This change does nothing except makes it more consistent with other types which are also just a wrapper around `Span` e.g. `NullLiteral` and `TSThisType`. --- crates/oxc_ast/src/ast/js.rs | 14 ++++++++------ crates/oxc_ast/src/ast_kind.rs | 4 ++-- crates/oxc_ast/src/serialize.rs | 19 +++++++++---------- crates/oxc_ast/src/span.rs | 2 +- crates/oxc_ast/src/visit/visit.rs | 11 +++++------ crates/oxc_ast/src/visit/visit_mut.rs | 9 ++++----- .../src/rules/eslint/no_sparse_arrays.rs | 6 +++--- crates/oxc_parser/src/js/expression.rs | 2 +- 8 files changed, 33 insertions(+), 34 deletions(-) diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs index fed962147..bc9ce0972 100644 --- a/crates/oxc_ast/src/ast/js.rs +++ b/crates/oxc_ast/src/ast/js.rs @@ -442,12 +442,7 @@ pub enum ArrayExpressionElement<'a> { Expression(Expression<'a>), /// Array hole for sparse arrays /// - // Serialize as `null`. `serialize_elision` in serialize.rs. - #[cfg_attr( - feature = "serialize", - serde(serialize_with = "ArrayExpressionElement::serialize_elision") - )] - Elision(Span), + Elision(Elision), } impl<'a> ArrayExpressionElement<'a> { @@ -456,6 +451,13 @@ impl<'a> ArrayExpressionElement<'a> { } } +/// Array Expression Elision Element +/// Serialized as `null` in JSON AST. See `serialize.rs`. +#[derive(Debug, Clone, Hash)] +pub struct Elision { + pub span: Span, +} + /// Object Expression #[derive(Debug, Hash)] #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))] diff --git a/crates/oxc_ast/src/ast_kind.rs b/crates/oxc_ast/src/ast_kind.rs index 28099348b..513d16a7e 100644 --- a/crates/oxc_ast/src/ast_kind.rs +++ b/crates/oxc_ast/src/ast_kind.rs @@ -98,7 +98,7 @@ ast_kinds! { SimpleAssignmentTarget(&'a SimpleAssignmentTarget<'a>), AssignmentTargetWithDefault(&'a AssignmentTargetWithDefault<'a>), ArrayExpressionElement(&'a ArrayExpressionElement<'a>), - Elision(Span), + Elision(&'a Elision), ExpressionArrayElement(&'a Expression<'a>), SpreadElement(&'a SpreadElement<'a>), BindingRestElement(&'a BindingRestElement<'a>), @@ -436,7 +436,7 @@ impl<'a> GetSpan for AstKind<'a> { Self::SimpleAssignmentTarget(x) => x.span(), Self::AssignmentTargetWithDefault(x) => x.span, Self::SpreadElement(x) => x.span, - Self::Elision(span) => *span, + Self::Elision(x) => x.span, Self::ExpressionArrayElement(x) => x.span(), Self::BindingRestElement(x) => x.span, diff --git a/crates/oxc_ast/src/serialize.rs b/crates/oxc_ast/src/serialize.rs index b62d9e901..7a71de213 100644 --- a/crates/oxc_ast/src/serialize.rs +++ b/crates/oxc_ast/src/serialize.rs @@ -4,10 +4,10 @@ use serde::{ }; use crate::ast::{ - ArrayAssignmentTarget, ArrayExpressionElement, ArrayPattern, AssignmentTargetMaybeDefault, - AssignmentTargetProperty, AssignmentTargetRest, BindingPattern, BindingPatternKind, - BindingProperty, BindingRestElement, FormalParameter, FormalParameterKind, FormalParameters, - ObjectAssignmentTarget, ObjectPattern, Program, RegExpFlags, TSTypeAnnotation, + ArrayAssignmentTarget, ArrayPattern, AssignmentTargetMaybeDefault, AssignmentTargetProperty, + AssignmentTargetRest, BindingPattern, BindingPatternKind, BindingProperty, BindingRestElement, + Elision, FormalParameter, FormalParameterKind, FormalParameters, ObjectAssignmentTarget, + ObjectPattern, Program, RegExpFlags, TSTypeAnnotation, }; use oxc_allocator::{Box, Vec}; use oxc_span::Span; @@ -46,12 +46,11 @@ impl Serialize for RegExpFlags { } /// Serialize `ArrayExpressionElement::Elision` variant as `null` in JSON -impl<'a> ArrayExpressionElement<'a> { - #[allow(clippy::trivially_copy_pass_by_ref)] - pub(crate) fn serialize_elision( - _span: &Span, - serializer: S, - ) -> Result { +impl Serialize for Elision { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { serializer.serialize_none() } } diff --git a/crates/oxc_ast/src/span.rs b/crates/oxc_ast/src/span.rs index 3e24d0f22..c636b95f2 100644 --- a/crates/oxc_ast/src/span.rs +++ b/crates/oxc_ast/src/span.rs @@ -239,7 +239,7 @@ impl<'a> GetSpan for ArrayExpressionElement<'a> { match self { Self::SpreadElement(e) => e.span, Self::Expression(expr) => expr.span(), - Self::Elision(span) => *span, + Self::Elision(elision) => elision.span, } } } diff --git a/crates/oxc_ast/src/visit/visit.rs b/crates/oxc_ast/src/visit/visit.rs index 8e7fc4164..d98d6882c 100644 --- a/crates/oxc_ast/src/visit/visit.rs +++ b/crates/oxc_ast/src/visit/visit.rs @@ -5,7 +5,6 @@ //! * [rustc visitor](https://github.com/rust-lang/rust/blob/master/compiler/rustc_ast/src/visit.rs) use oxc_allocator::Vec; -use oxc_span::Span; use oxc_syntax::scope::ScopeFlags; use crate::{ast::*, ast_kind::AstKind}; @@ -240,8 +239,8 @@ pub trait Visit<'a>: Sized { walk_expression_array_element(self, expr); } - fn visit_elision(&mut self, span: Span) { - walk_elision(self, span); + fn visit_elision(&mut self, elision: &Elision) { + walk_elision(self, elision); } fn visit_assignment_expression(&mut self, expr: &AssignmentExpression<'a>) { @@ -1502,7 +1501,7 @@ pub mod walk { ArrayExpressionElement::Expression(expr) => { visitor.visit_expression_array_element(expr); } - ArrayExpressionElement::Elision(span) => visitor.visit_elision(*span), + ArrayExpressionElement::Elision(elision) => visitor.visit_elision(elision), } visitor.leave_node(kind); } @@ -1531,8 +1530,8 @@ pub mod walk { visitor.leave_node(kind); } - pub fn walk_elision<'a, V: Visit<'a>>(visitor: &mut V, span: Span) { - let kind = AstKind::Elision(span); + pub fn walk_elision<'a, V: Visit<'a>>(visitor: &mut V, elision: &Elision) { + let kind = AstKind::Elision(visitor.alloc(elision)); visitor.enter_node(kind); visitor.leave_node(kind); } diff --git a/crates/oxc_ast/src/visit/visit_mut.rs b/crates/oxc_ast/src/visit/visit_mut.rs index 30052622d..8eac175c2 100644 --- a/crates/oxc_ast/src/visit/visit_mut.rs +++ b/crates/oxc_ast/src/visit/visit_mut.rs @@ -1,7 +1,6 @@ //! Visit Mut Pattern use oxc_allocator::Vec; -use oxc_span::Span; use oxc_syntax::scope::ScopeFlags; use crate::{ast::*, AstType}; @@ -227,8 +226,8 @@ pub trait VisitMut<'a>: Sized { walk_expression_array_element_mut(self, expr); } - fn visit_elision(&mut self, span: Span) { - walk_elision_mut(self, span); + fn visit_elision(&mut self, elision: &mut Elision) { + walk_elision_mut(self, elision); } fn visit_assignment_expression(&mut self, expr: &mut AssignmentExpression<'a>) { @@ -1536,7 +1535,7 @@ pub mod walk_mut { ArrayExpressionElement::Expression(expr) => { visitor.visit_expression_array_element(expr); } - ArrayExpressionElement::Elision(span) => visitor.visit_elision(*span), + ArrayExpressionElement::Elision(elision) => visitor.visit_elision(elision), } visitor.leave_node(kind); } @@ -1571,7 +1570,7 @@ pub mod walk_mut { visitor.leave_node(kind); } - pub fn walk_elision_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _span: Span) { + pub fn walk_elision_mut<'a, V: VisitMut<'a>>(visitor: &mut V, _elision: &mut Elision) { let kind = AstType::Elision; visitor.enter_node(kind); visitor.leave_node(kind); diff --git a/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs b/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs index 8f97a1079..11ce853f6 100644 --- a/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs +++ b/crates/oxc_linter/src/rules/eslint/no_sparse_arrays.rs @@ -42,12 +42,12 @@ impl Rule for NoSparseArrays { .elements .iter() .filter_map(|el| match el { - ArrayExpressionElement::Elision(span) => Some(span), + ArrayExpressionElement::Elision(elision) => Some(elision), _ => None, }) - .map(|span| { + .map(|elision| { LabeledSpan::at( - (span.start as usize)..(span.start as usize), + (elision.span.start as usize)..(elision.span.start as usize), "unexpected comma", ) }) diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs index dd5bb4031..e925329ea 100644 --- a/crates/oxc_parser/src/js/expression.rs +++ b/crates/oxc_parser/src/js/expression.rs @@ -368,7 +368,7 @@ impl<'a> ParserImpl<'a> { /// , /// Elision , pub(crate) fn parse_elision(&mut self) -> ArrayExpressionElement<'a> { - ArrayExpressionElement::Elision(self.cur_token().span()) + ArrayExpressionElement::Elision(Elision { span: self.cur_token().span() }) } /// Section [Template Literal](https://tc39.es/ecma262/#prod-TemplateLiteral)