fix

Author: kdy1

crates/swc_ecma_fast_parser/src/parser/expr.rs

@@ -2,7 +2,7 @@
 //!
 //! This module contains methods for parsing JavaScript expressions.
 
-use swc_common::Span;
+use swc_common::{Span, Spanned};
 use swc_ecma_ast::{
     ArrayLit, AwaitExpr, BinExpr, BinaryOp, Bool, Expr, ExprOrSpread, Lit, Null, ObjectLit,
     ParenExpr, PropOrSpread, SpreadElement, ThisExpr, UnaryExpr, UnaryOp, UpdateExpr, UpdateOp,
@@ -11,7 +11,7 @@ use swc_ecma_ast::{
 
 use crate::{
     error::{Error, ErrorKind, Result},
-    parser::{util, util::GetSpan, Parser},
+    parser::{util, Parser},
     token::{TokenType, TokenValue},
 };
 

crates/swc_ecma_fast_parser/src/parser/pat.rs

@@ -3,15 +3,15 @@
 //! This module contains methods for parsing JavaScript patterns (destructuring,
 //! etc.).
 
-use swc_common::Span;
+use swc_common::{Span, Spanned};
 use swc_ecma_ast::{
     ArrayPat, AssignPat, AssignPatProp, BindingIdent, ComputedPropName, IdentName, KeyValuePatProp,
     ObjectPat, ObjectPatProp, Pat, PropName, RestPat,
 };
 
 use crate::{
     error::{Error, ErrorKind, Result},
-    parser::{util, util::GetSpan, Parser},
+    parser::{util, Parser},
     token::TokenType,
 };
 

crates/swc_ecma_fast_parser/src/parser/stmt.rs

@@ -2,14 +2,10 @@
 //!
 //! This module contains methods for parsing JavaScript statements.
 
-use swc_common::{Span, SyntaxContext};
+use swc_common::{Span, Spanned, SyntaxContext};
 use swc_ecma_ast::{BlockStmt, ExprStmt, ReturnStmt, Stmt, VarDecl, VarDeclKind, VarDeclarator};
 
-use crate::{
-    error::Result,
-    parser::{util::GetSpan, Parser},
-    token::TokenType,
-};
+use crate::{error::Result, parser::Parser, token::TokenType};
 
 impl Parser<'_> {
     /// Parse a statement

crates/swc_ecma_fast_parser/src/parser/util.rs

@@ -2,106 +2,13 @@
 
 use swc_atoms::Atom;
 use swc_common::{Span, SyntaxContext};
-use swc_ecma_ast::{BindingIdent, Expr, Ident, Number, Pat, Str};
+use swc_ecma_ast::{BindingIdent, Ident, Number, Str};
 
 use crate::{
     error::{Error, ErrorKind},
     token::{Token, TokenType, TokenValue},
 };
 
-/// Trait for getting spans from AST nodes
-pub trait GetSpan {
-    fn span(&self) -> Span;
-}
-
-// Implement GetSpan for Box<Expr>
-impl GetSpan for Box<Expr> {
-    fn span(&self) -> Span {
-        match &**self {
-            Expr::Array(e) => e.span,
-            Expr::Arrow(e) => e.span,
-            Expr::Assign(e) => e.span,
-            Expr::Await(e) => e.span,
-            Expr::Bin(e) => e.span,
-            Expr::Call(e) => e.span,
-            Expr::Class(e) => {
-                if let Some(ident) = &e.ident {
-                    ident.span
-                } else {
-                    e.class.span
-                }
-            }
-            Expr::Cond(e) => e.span,
-            Expr::Fn(e) => {
-                if let Some(ident) = &e.ident {
-                    ident.span
-                } else {
-                    e.function.span
-                }
-            }
-            Expr::Ident(e) => e.span,
-            Expr::Lit(e) => match e {
-                swc_ecma_ast::Lit::Str(s) => s.span,
-                swc_ecma_ast::Lit::Bool(b) => b.span,
-                swc_ecma_ast::Lit::Null(n) => n.span,
-                swc_ecma_ast::Lit::Num(n) => n.span,
-                swc_ecma_ast::Lit::BigInt(b) => b.span,
-                swc_ecma_ast::Lit::Regex(r) => r.span,
-                swc_ecma_ast::Lit::JSXText(j) => j.span,
-            },
-            Expr::Member(e) => e.span,
-            Expr::MetaProp(e) => e.span,
-            Expr::New(e) => e.span,
-            Expr::Object(e) => e.span,
-            Expr::OptChain(e) => e.span,
-            Expr::Paren(e) => e.span,
-            Expr::PrivateName(e) => e.span,
-            Expr::Seq(e) => e.span,
-            Expr::SuperProp(e) => e.span,
-            Expr::TaggedTpl(e) => e.span,
-            Expr::This(e) => e.span,
-            Expr::Tpl(e) => e.span,
-            Expr::Unary(e) => e.span,
-            Expr::Update(e) => e.span,
-            Expr::Yield(e) => e.span,
-            Expr::JSXMember(e) => e.span,
-            Expr::JSXNamespacedName(e) => e.span,
-            Expr::JSXEmpty(e) => e.span,
-            Expr::JSXElement(e) => e.span,
-            Expr::JSXFragment(e) => e.span,
-            Expr::TsTypeAssertion(e) => e.span,
-            Expr::TsConstAssertion(e) => e.span,
-            Expr::TsNonNull(e) => e.span,
-            Expr::TsAs(e) => e.span,
-            Expr::TsInstantiation(e) => e.span,
-            Expr::TsSatisfies(e) => e.span,
-            Expr::Invalid(e) => e.span,
-        }
-    }
-}
-
-// Implement GetSpan for Pat
-impl GetSpan for Pat {
-    fn span(&self) -> Span {
-        match self {
-            Pat::Ident(i) => i.id.span,
-            Pat::Array(a) => a.span,
-            Pat::Rest(r) => r.span,
-            Pat::Object(o) => o.span,
-            Pat::Assign(a) => a.span,
-            Pat::Invalid(i) => i.span,
-            Pat::Expr(e) => e.span(),
-        }
-    }
-}
-
-// Implement GetSpan for BindingIdent
-impl GetSpan for BindingIdent {
-    fn span(&self) -> Span {
-        self.id.span
-    }
-}
-
 /// Convert a token value to an identifier
 pub fn token_value_to_ident(token: &Token, span: Span) -> Ident {
     if let TokenValue::Str { value, .. } = &token.value {