fix ecma parser

quininer · quininer · commit 7e9b1f38912c · 2025-09-22T20:19:16.000+08:00
diff --git a/crates/swc_ecma_lexer/src/common/parser/class_and_fn.rs b/crates/swc_ecma_lexer/src/common/parser/class_and_fn.rs
@@ -581,7 +581,8 @@ where
                 kind,
             }
             .into())
-        }
+        },
+        _ => unreachable!()
     }
 }
 
@@ -817,6 +818,7 @@ fn make_property<'a, P: Parser<'a>>(
                 }
                 .into()
             }
+            _ => unreachable!()
         })
     })
 }
diff --git a/crates/swc_ecma_lexer/src/common/parser/expr.rs b/crates/swc_ecma_lexer/src/common/parser/expr.rs
@@ -586,6 +586,7 @@ fn parse_subscript<'a, P: Parser<'a>>(
                     )
                 }
                 Callee::Expr(expr) => expr,
+                _ => unreachable!()
             };
             return Ok((
                 TsNonNullExpr {
@@ -808,6 +809,7 @@ fn parse_subscript<'a, P: Parser<'a>>(
                         expr
                     }
                 }
+                _ => unreachable!()
             }),
             true,
         ));
@@ -853,6 +855,7 @@ fn parse_subscript<'a, P: Parser<'a>>(
                     .into(),
                     true,
                 )),
+                _ => unreachable!()
             }
         } else {
             Ok((
@@ -944,6 +947,7 @@ fn parse_subscript<'a, P: Parser<'a>>(
                                 )
                             }
                             MemberProp::Computed(..) => unreachable!(),
+                            _ => unreachable!()
                         }
                     }
                 }
@@ -972,6 +976,7 @@ fn parse_subscript<'a, P: Parser<'a>>(
                         expr
                     }
                 }
+                _ => unreachable!()
             }),
             true,
         ));
@@ -1013,6 +1018,7 @@ fn parse_subscript<'a, P: Parser<'a>>(
         Callee::Import(..) => {
             syntax_error!(p, p.input().cur_span(), SyntaxError::InvalidImport);
         }
+        _ => unreachable!()
     }
 }
 
@@ -1962,6 +1968,7 @@ fn parse_args_or_pats_inner<'a, P: Parser<'a>>(
                     // creating `Invalid`, we don't have to emit a new
                     // error.
                 }
+                _ => ()
             }
 
             if p.input_mut().eat(&P::Token::EQUAL) {
diff --git a/crates/swc_ecma_lexer/src/common/parser/expr_ext.rs b/crates/swc_ecma_lexer/src/common/parser/expr_ext.rs
@@ -74,6 +74,8 @@ pub trait ExprExt {
             Expr::TsConstAssertion(..) => false,
 
             Expr::Invalid(..) => false,
+
+            _ => false,
         }
     }
 }
diff --git a/crates/swc_ecma_lexer/src/common/parser/jsx.rs b/crates/swc_ecma_lexer/src/common/parser/jsx.rs
@@ -101,6 +101,7 @@ fn parse_jsx_element_name<'a, P: Parser<'a>>(p: &mut P) -> PResult<JSXElementNam
     let mut node = match parse_jsx_namespaced_name(p)? {
         JSXAttrName::Ident(i) => JSXElementName::Ident(i.into()),
         JSXAttrName::JSXNamespacedName(i) => JSXElementName::JSXNamespacedName(i),
+        _ => unreachable!()
     };
     while p.input_mut().eat(&P::Token::DOT) {
         let prop = parse_jsx_ident(p).map(IdentName::from)?;
@@ -149,6 +150,7 @@ pub fn jsx_expr_container_to_jsx_attr_value<'a, P: Parser<'a>>(
             syntax_error!(p, p.span(start), SyntaxError::EmptyJSXAttr)
         }
         JSXExpr::Expr(..) => Ok(node.into()),
+        _ => unreachable!()
     }
 }
 
diff --git a/crates/swc_ecma_lexer/src/common/parser/module_item.rs b/crates/swc_ecma_lexer/src/common/parser/module_item.rs
@@ -331,6 +331,8 @@ fn parse_import_specifier<'a, P: Parser<'a>>(
                 )
             }
         }
+
+        _ => unreachable!()
     }
 }
 
@@ -685,6 +687,7 @@ fn parse_export<'a, P: Parser<'a>>(
                         let export_name = match &namespace.name {
                             ModuleExportName::Ident(i) => i.sym.clone(),
                             ModuleExportName::Str(s) => s.value.clone(),
+                            _ => unreachable!()
                         };
                         p.emit_err(namespace.span, SyntaxError::ExportExpectFrom(export_name));
                     }
@@ -697,6 +700,7 @@ fn parse_export<'a, P: Parser<'a>>(
                         }
                         _ => {}
                     },
+                    _ => ()
                 }
             }
 
diff --git a/crates/swc_ecma_lexer/src/common/parser/pat.rs b/crates/swc_ecma_lexer/src/common/parser/pat.rs
@@ -51,11 +51,13 @@ fn pat_is_valid_argument_in_strict<'a>(p: &mut impl Parser<'a>, pat: &Pat) {
                             p.emit_strict_mode_err(key.span, SyntaxError::EvalAndArgumentsInStrict)
                         }
                     }
+                    _ => ()
                 }
             }
         }
         Pat::Assign(a) => pat_is_valid_argument_in_strict(p, &a.left),
         Pat::Invalid(_) | Pat::Expr(_) => (),
+        _ => (),
     }
 }
 
@@ -175,6 +177,7 @@ fn reparse_expr_as_pat_inner<'a>(
                         Box::new(reparse_expr_as_pat(p, pat_ty, left.into())?)
                     }
                     AssignTarget::Pat(pat) => pat.into(),
+                    _ => unreachable!()
                 },
                 right,
             }
@@ -250,6 +253,8 @@ fn reparse_expr_as_pat_inner<'a>(
                                     type_ann: None,
                                 }))
                             }
+
+                            _ => unreachable!()
                         }
                     })
                     .collect::<PResult<_>>()?,
diff --git a/crates/swc_ecma_lexer/src/common/parser/stmt.rs b/crates/swc_ecma_lexer/src/common/parser/stmt.rs
@@ -783,6 +783,7 @@ fn parse_catch_param<'a, P: Parser<'a>>(p: &mut P) -> PResult<Option<Pat>> {
                 Pat::Assign(..) => {}
                 Pat::Invalid(_) => {}
                 Pat::Expr(_) => {}
+                _ => {}
             }
         }
         expect!(p, &P::Token::RPAREN);
diff --git a/crates/swc_ecma_lexer/src/common/parser/util.rs b/crates/swc_ecma_lexer/src/common/parser/util.rs
@@ -59,6 +59,7 @@ pub fn get_qualified_jsx_name(name: &JSXElementName) -> Atom {
                 member.prop.sym
             )
             .into(),
+            _ => unreachable!()
         }
     }
     match *name {
@@ -69,6 +70,7 @@ pub fn get_qualified_jsx_name(name: &JSXElementName) -> Atom {
         JSXElementName::JSXMemberExpr(JSXMemberExpr {
             ref obj, ref prop, ..
         }) => format!("{}.{}", get_qualified_obj_name(obj), prop.sym).into(),
+        _ => unreachable!()
     }
 }
 
@@ -83,6 +85,7 @@ pub fn make_decl_declare(mut decl: Decl) -> Decl {
         Decl::TsEnum(ref mut e) => e.declare = true,
         Decl::TsModule(ref mut m) => m.declare = true,
         Decl::Using(..) => unreachable!("Using is not a valid declaration for `declare` keyword"),
+        _ => unreachable!()
     }
     decl
 }
diff --git a/crates/swc_ecma_lexer/src/parser/mod.rs b/crates/swc_ecma_lexer/src/parser/mod.rs
@@ -251,6 +251,7 @@ impl<I: Tokens<TokenAndSpan>> Parser<I> {
     above"
                     ),
                     ModuleItem::Stmt(stmt) => stmt,
+                    _ => unreachable!()
                 })
                 .collect();
             Program::Script(Script {
diff --git a/crates/swc_ecma_parser/src/parser/jsx/mod.rs b/crates/swc_ecma_parser/src/parser/jsx/mod.rs
@@ -82,6 +82,7 @@ impl<I: Tokens> Parser<I> {
         let mut node = match self.parse_jsx_tag_name()? {
             JSXAttrName::Ident(i) => JSXElementName::Ident(i.into()),
             JSXAttrName::JSXNamespacedName(i) => JSXElementName::JSXNamespacedName(i),
+            _ => unreachable!()
         };
         while self.input_mut().eat(&Token::Dot) {
             self.input_mut().scan_jsx_identifier();
diff --git a/crates/swc_ecma_parser/src/parser/mod.rs b/crates/swc_ecma_parser/src/parser/mod.rs
@@ -295,6 +295,7 @@ impl<I: Tokens> Parser<I> {
                 .map(|item| match item {
                     ModuleItem::ModuleDecl(_) => unreachable!("Module is handled above"),
                     ModuleItem::Stmt(stmt) => stmt,
+                    _ => unreachable!()
                 })
                 .collect();
             Program::Script(Script {

Original file line number	Diff line number	Diff line change
`@@ -581,7 +581,8 @@ where`
`581`	`581`	`kind,`
`582`	`582`	`}`
`583`	`583`	`.into())`
`584`		`- }`
	`584`	`+ },`
	`585`	`+ _ => unreachable!()`
`585`	`586`	`}`
`586`	`587`	`}`
`587`	`588`
`@@ -817,6 +818,7 @@ fn make_property<'a, P: Parser<'a>>(`
`817`	`818`	`}`
`818`	`819`	`.into()`
`819`	`820`	`}`
	`821`	`+ _ => unreachable!()`
`820`	`822`	`})`
`821`	`823`	`})`
`822`	`824`	`}`
Original file line number	Diff line number	Diff line change
`@@ -586,6 +586,7 @@ fn parse_subscript<'a, P: Parser<'a>>(`
`586`	`586`	`)`
`587`	`587`	`}`
`588`	`588`	`Callee::Expr(expr) => expr,`
	`589`	`+ _ => unreachable!()`
`589`	`590`	`};`
`590`	`591`	`return Ok((`
`591`	`592`	`TsNonNullExpr {`
`@@ -808,6 +809,7 @@ fn parse_subscript<'a, P: Parser<'a>>(`
`808`	`809`	`expr`
`809`	`810`	`}`
`810`	`811`	`}`
	`812`	`+ _ => unreachable!()`
`811`	`813`	`}),`
`812`	`814`	`true,`
`813`	`815`	`));`
`@@ -853,6 +855,7 @@ fn parse_subscript<'a, P: Parser<'a>>(`
`853`	`855`	`.into(),`
`854`	`856`	`true,`
`855`	`857`	`)),`
	`858`	`+ _ => unreachable!()`
`856`	`859`	`}`
`857`	`860`	`} else {`
`858`	`861`	`Ok((`
`@@ -944,6 +947,7 @@ fn parse_subscript<'a, P: Parser<'a>>(`
`944`	`947`	`)`
`945`	`948`	`}`
`946`	`949`	`MemberProp::Computed(..) => unreachable!(),`
	`950`	`+ _ => unreachable!()`
`947`	`951`	`}`
`948`	`952`	`}`
`949`	`953`	`}`
`@@ -972,6 +976,7 @@ fn parse_subscript<'a, P: Parser<'a>>(`
`972`	`976`	`expr`
`973`	`977`	`}`
`974`	`978`	`}`
	`979`	`+ _ => unreachable!()`
`975`	`980`	`}),`
`976`	`981`	`true,`
`977`	`982`	`));`
`@@ -1013,6 +1018,7 @@ fn parse_subscript<'a, P: Parser<'a>>(`
`1013`	`1018`	`Callee::Import(..) => {`
`1014`	`1019`	`syntax_error!(p, p.input().cur_span(), SyntaxError::InvalidImport);`
`1015`	`1020`	`}`
	`1021`	`+ _ => unreachable!()`
`1016`	`1022`	`}`
`1017`	`1023`	`}`
`1018`	`1024`
`@@ -1962,6 +1968,7 @@ fn parse_args_or_pats_inner<'a, P: Parser<'a>>(`
`1962`	`1968`	// creating `Invalid`, we don't have to emit a new
`1963`	`1969`	`// error.`
`1964`	`1970`	`}`
	`1971`	`+ _ => ()`
`1965`	`1972`	`}`
`1966`	`1973`
`1967`	`1974`	`if p.input_mut().eat(&P::Token::EQUAL) {`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,8 @@ pub trait ExprExt {`
`74`	`74`	`Expr::TsConstAssertion(..) => false,`
`75`	`75`
`76`	`76`	`Expr::Invalid(..) => false,`
	`77`	`+`
	`78`	`+ _ => false,`
`77`	`79`	`}`
`78`	`80`	`}`
`79`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -101,6 +101,7 @@ fn parse_jsx_element_name<'a, P: Parser<'a>>(p: &mut P) -> PResult<JSXElementNam`
`101`	`101`	`let mut node = match parse_jsx_namespaced_name(p)? {`
`102`	`102`	`JSXAttrName::Ident(i) => JSXElementName::Ident(i.into()),`
`103`	`103`	`JSXAttrName::JSXNamespacedName(i) => JSXElementName::JSXNamespacedName(i),`
	`104`	`+ _ => unreachable!()`
`104`	`105`	`};`
`105`	`106`	`while p.input_mut().eat(&P::Token::DOT) {`
`106`	`107`	`let prop = parse_jsx_ident(p).map(IdentName::from)?;`
`@@ -149,6 +150,7 @@ pub fn jsx_expr_container_to_jsx_attr_value<'a, P: Parser<'a>>(`
`149`	`150`	`syntax_error!(p, p.span(start), SyntaxError::EmptyJSXAttr)`
`150`	`151`	`}`
`151`	`152`	`JSXExpr::Expr(..) => Ok(node.into()),`
	`153`	`+ _ => unreachable!()`
`152`	`154`	`}`
`153`	`155`	`}`
`154`	`156`
Original file line number	Diff line number	Diff line change
`@@ -331,6 +331,8 @@ fn parse_import_specifier<'a, P: Parser<'a>>(`
`331`	`331`	`)`
`332`	`332`	`}`
`333`	`333`	`}`
	`334`	`+`
	`335`	`+ _ => unreachable!()`
`334`	`336`	`}`
`335`	`337`	`}`
`336`	`338`
`@@ -685,6 +687,7 @@ fn parse_export<'a, P: Parser<'a>>(`
`685`	`687`	`let export_name = match &namespace.name {`
`686`	`688`	`ModuleExportName::Ident(i) => i.sym.clone(),`
`687`	`689`	`ModuleExportName::Str(s) => s.value.clone(),`
	`690`	`+ _ => unreachable!()`
`688`	`691`	`};`
`689`	`692`	`p.emit_err(namespace.span, SyntaxError::ExportExpectFrom(export_name));`
`690`	`693`	`}`
`@@ -697,6 +700,7 @@ fn parse_export<'a, P: Parser<'a>>(`
`697`	`700`	`}`
`698`	`701`	`_ => {}`
`699`	`702`	`},`
	`703`	`+ _ => ()`
`700`	`704`	`}`
`701`	`705`	`}`
`702`	`706`
Original file line number	Diff line number	Diff line change
`@@ -51,11 +51,13 @@ fn pat_is_valid_argument_in_strict<'a>(p: &mut impl Parser<'a>, pat: &Pat) {`
`51`	`51`	`p.emit_strict_mode_err(key.span, SyntaxError::EvalAndArgumentsInStrict)`
`52`	`52`	`}`
`53`	`53`	`}`
	`54`	`+ _ => ()`
`54`	`55`	`}`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`	`Pat::Assign(a) => pat_is_valid_argument_in_strict(p, &a.left),`
`58`	`59`	`Pat::Invalid(_) \| Pat::Expr(_) => (),`
	`60`	`+ _ => (),`
`59`	`61`	`}`
`60`	`62`	`}`
`61`	`63`
`@@ -175,6 +177,7 @@ fn reparse_expr_as_pat_inner<'a>(`
`175`	`177`	`Box::new(reparse_expr_as_pat(p, pat_ty, left.into())?)`
`176`	`178`	`}`
`177`	`179`	`AssignTarget::Pat(pat) => pat.into(),`
	`180`	`+ _ => unreachable!()`
`178`	`181`	`},`
`179`	`182`	`right,`
`180`	`183`	`}`
`@@ -250,6 +253,8 @@ fn reparse_expr_as_pat_inner<'a>(`
`250`	`253`	`type_ann: None,`
`251`	`254`	`}))`
`252`	`255`	`}`
	`256`	`+`
	`257`	`+ _ => unreachable!()`
`253`	`258`	`}`
`254`	`259`	`})`
`255`	`260`	`.collect::<PResult<_>>()?,`
Original file line number	Diff line number	Diff line change
`@@ -783,6 +783,7 @@ fn parse_catch_param<'a, P: Parser<'a>>(p: &mut P) -> PResult<Option<Pat>> {`
`783`	`783`	`Pat::Assign(..) => {}`
`784`	`784`	`Pat::Invalid(_) => {}`
`785`	`785`	`Pat::Expr(_) => {}`
	`786`	`+ _ => {}`
`786`	`787`	`}`
`787`	`788`	`}`
`788`	`789`	`expect!(p, &P::Token::RPAREN);`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,7 @@ pub fn get_qualified_jsx_name(name: &JSXElementName) -> Atom {`
`59`	`59`	`member.prop.sym`
`60`	`60`	`)`
`61`	`61`	`.into(),`
	`62`	`+ _ => unreachable!()`
`62`	`63`	`}`
`63`	`64`	`}`
`64`	`65`	`match *name {`
`@@ -69,6 +70,7 @@ pub fn get_qualified_jsx_name(name: &JSXElementName) -> Atom {`
`69`	`70`	`JSXElementName::JSXMemberExpr(JSXMemberExpr {`
`70`	`71`	`ref obj, ref prop, ..`
`71`	`72`	`}) => format!("{}.{}", get_qualified_obj_name(obj), prop.sym).into(),`
	`73`	`+ _ => unreachable!()`
`72`	`74`	`}`
`73`	`75`	`}`
`74`	`76`
`@@ -83,6 +85,7 @@ pub fn make_decl_declare(mut decl: Decl) -> Decl {`
`83`	`85`	`Decl::TsEnum(ref mut e) => e.declare = true,`
`84`	`86`	`Decl::TsModule(ref mut m) => m.declare = true,`
`85`	`87`	Decl::Using(..) => unreachable!("Using is not a valid declaration for `declare` keyword"),
	`88`	`+ _ => unreachable!()`
`86`	`89`	`}`
`87`	`90`	`decl`
`88`	`91`	`}`